@withone/cli 1.29.0 → 1.31.0

package/dist/index.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import {
+  ApiError,
   FLOW_SCHEMA,
   FlowRunner,
   OneApi,
@@ -8,6 +9,7 @@ import {
   filterByPermissions,
   flowRequiresBash,
   generateFlowGuide,
+  getByDotPath,
   getNestedStepsKeys,
   getStepTypeDescriptor,
   isActionAllowed,
@@ -15,8 +17,9 @@ import {
   listFlows,
   loadFlowWithMeta,
   resolveFlowPath,
-  saveFlow
-} from "./chunk-AZV4EGKT.js";
+  saveFlow,
+  validateActionInput
+} from "./chunk-645Z3ARQ.js";
 
 // src/index.ts
 import { createRequire as createRequire2 } from "module";
@@ -224,11 +227,11 @@ import fs2 from "fs";
 import path2 from "path";
 import os2 from "os";
 import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
-function expandPath(p7) {
-  if (p7.startsWith("~/")) {
-    return path2.join(os2.homedir(), p7.slice(2));
+function expandPath(p8) {
+  if (p8.startsWith("~/")) {
+    return path2.join(os2.homedir(), p8.slice(2));
   }
-  return p7;
+  return p8;
 }
 function getClaudeDesktopConfigPath() {
   switch (process.platform) {
@@ -444,6 +447,9 @@ function outro2(msg) {
 function note2(msg, title) {
   if (!isAgentMode()) p.note(msg, title);
 }
+function cancel2(msg) {
+  if (!isAgentMode()) p.cancel(msg);
+}
 function json(data) {
   process.stdout.write(JSON.stringify(data) + "\n");
 }
@@ -1506,16 +1512,16 @@ import pc4 from "picocolors";
 function findPlatform(platforms, query) {
   const normalizedQuery = query.toLowerCase().trim();
   const exact = platforms.find(
-    (p7) => p7.platform.toLowerCase() === normalizedQuery || p7.name.toLowerCase() === normalizedQuery
+    (p8) => p8.platform.toLowerCase() === normalizedQuery || p8.name.toLowerCase() === normalizedQuery
   );
   if (exact) return exact;
   return null;
 }
 function findSimilarPlatforms(platforms, query, limit = 3) {
   const normalizedQuery = query.toLowerCase().trim();
-  const scored = platforms.map((p7) => {
-    const name = p7.name.toLowerCase();
-    const slug = p7.platform.toLowerCase();
+  const scored = platforms.map((p8) => {
+    const name = p8.name.toLowerCase();
+    const slug = p8.platform.toLowerCase();
     let score = 0;
     if (name.includes(normalizedQuery) || slug.includes(normalizedQuery)) {
       score = 10;
@@ -1524,7 +1530,7 @@ function findSimilarPlatforms(platforms, query, limit = 3) {
     } else {
       score = countMatchingChars(normalizedQuery, slug);
     }
-    return { platform: p7, score };
+    return { platform: p8, score };
   }).filter((item) => item.score > 0).sort((a, b) => b.score - a.score).slice(0, limit);
   return scored.map((item) => item.platform);
 }
@@ -1849,35 +1855,33 @@ async function platformsCommand(options) {
   try {
     const platforms = await api.listPlatforms();
     spinner5.stop(`${platforms.length} platforms available`);
+    let filtered = platforms;
+    if (options.category) {
+      filtered = platforms.filter((plat) => (plat.category || "Other") === options.category);
+      if (filtered.length === 0) {
+        const categories = [...new Set(platforms.map((plat) => plat.category || "Other"))].sort();
+        if (isAgentMode()) {
+          json({ error: `Unknown category "${options.category}"`, availableCategories: categories });
+          process.exit(1);
+        }
+        p5.note(`Available categories:
+  ${categories.join(", ")}`, "Unknown Category");
+        process.exit(1);
+      }
+    }
     if (options.json) {
       if (isAgentMode()) {
-        json({ platforms });
+        json({ platforms: filtered });
       } else {
-        console.log(JSON.stringify(platforms, null, 2));
+        console.log(JSON.stringify(filtered, null, 2));
       }
       return;
     }
-    const byCategory = /* @__PURE__ */ new Map();
-    for (const plat of platforms) {
-      const category = plat.category || "Other";
-      if (!byCategory.has(category)) {
-        byCategory.set(category, []);
-      }
-      byCategory.get(category).push(plat);
-    }
     console.log();
     if (options.category) {
-      const categoryPlatforms = byCategory.get(options.category);
-      if (!categoryPlatforms) {
-        const categories = [...byCategory.keys()].sort();
-        p5.note(`Available categories:
-  ${categories.join(", ")}`, "Unknown Category");
-        process.exit(1);
-      }
-      const rows = categoryPlatforms.sort((a, b) => a.platform.localeCompare(b.platform)).map((plat) => ({
+      const rows = filtered.sort((a, b) => a.platform.localeCompare(b.platform)).map((plat) => ({
         platform: plat.platform,
-        name: plat.name,
-        category: plat.category || "Other"
+        name: plat.name
       }));
       printTable(
         [
@@ -1887,7 +1891,7 @@ async function platformsCommand(options) {
         rows
       );
     } else {
-      const rows = platforms.sort((a, b) => a.category.localeCompare(b.category) || a.platform.localeCompare(b.platform)).map((plat) => ({
+      const rows = filtered.sort((a, b) => (a.category || "Other").localeCompare(b.category || "Other") || a.platform.localeCompare(b.platform)).map((plat) => ({
         platform: plat.platform,
         name: plat.name,
         category: plat.category || "Other"
@@ -2058,11 +2062,11 @@ 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 cached2 = useCache ? readCache2(cachePath) : null;
     let cleanedActions;
     let cacheHit = false;
-    if (cached && isFresh(cached)) {
-      cleanedActions = cached.data.actions;
+    if (cached2 && isFresh(cached2)) {
+      cleanedActions = cached2.data.actions;
       cacheHit = true;
     } else {
       try {
@@ -2070,12 +2074,12 @@ async function actionsSearchCommand(platform, query, options) {
           platform,
           query,
           agentType,
-          cached?.etag ?? void 0
+          cached2?.etag ?? void 0
         );
-        if (result.status === 304 && cached) {
-          cached.cachedAt = (/* @__PURE__ */ new Date()).toISOString();
-          writeCache2(cachePath, cached);
-          cleanedActions = cached.data.actions;
+        if (result.status === 304 && cached2) {
+          cached2.cachedAt = (/* @__PURE__ */ new Date()).toISOString();
+          writeCache2(cachePath, cached2);
+          cleanedActions = cached2.data.actions;
           cacheHit = true;
         } else {
           let actions2 = result.data;
@@ -2094,12 +2098,12 @@ async function actionsSearchCommand(platform, query, options) {
           ));
         }
       } catch (fetchError) {
-        if (cached) {
+        if (cached2) {
           process.stderr.write(
-            `Warning: serving cached search results (network unavailable, cached ${formatAge(getAge(cached))} ago)
+            `Warning: serving cached search results (network unavailable, cached ${formatAge(getAge(cached2))} ago)
 `
           );
-          cleanedActions = cached.data.actions;
+          cleanedActions = cached2.data.actions;
           cacheHit = true;
         } else {
           throw fetchError;
@@ -2108,8 +2112,8 @@ async function actionsSearchCommand(platform, query, options) {
     }
     if (isAgentMode()) {
       const response = { actions: cleanedActions };
-      if (cacheHit && cached) {
-        response._cache = buildCacheMeta(cached, true);
+      if (cacheHit && cached2) {
+        response._cache = buildCacheMeta(cached2, true);
       } else {
         const freshEntry = readCache2(cachePath);
         response._cache = buildCacheMeta(freshEntry, false);
@@ -2219,23 +2223,23 @@ async function actionsKnowledgeCommand(platform, actionId, options) {
   spinner5.start(`Loading knowledge for action ${pc6.dim(actionId)}...`);
   try {
     const useCache = options.cache !== false;
-    const cached = useCache ? readCache2(cachePath) : null;
+    const cached2 = useCache ? readCache2(cachePath) : null;
     let knowledgeData;
     let cacheHit = false;
-    let cacheEntry = cached;
-    if (cached && isFresh(cached) && useCache) {
-      knowledgeData = cached.data;
+    let cacheEntry = cached2;
+    if (cached2 && isFresh(cached2) && useCache) {
+      knowledgeData = cached2.data;
       cacheHit = true;
     } else {
       try {
         const result = await api.getActionKnowledgeWithMeta(
           actionId,
-          cached?.etag ?? void 0
+          cached2?.etag ?? void 0
         );
-        if (result.status === 304 && cached) {
-          cached.cachedAt = (/* @__PURE__ */ new Date()).toISOString();
-          writeCache2(cachePath, cached);
-          knowledgeData = cached.data;
+        if (result.status === 304 && cached2) {
+          cached2.cachedAt = (/* @__PURE__ */ new Date()).toISOString();
+          writeCache2(cachePath, cached2);
+          knowledgeData = cached2.data;
           cacheHit = true;
         } else {
           knowledgeData = result.data;
@@ -2244,12 +2248,12 @@ async function actionsKnowledgeCommand(platform, actionId, options) {
           cacheEntry = newEntry;
         }
       } catch (fetchError) {
-        if (cached) {
+        if (cached2) {
           process.stderr.write(
-            `Warning: serving cached knowledge (network unavailable, cached ${formatAge(getAge(cached))} ago)
+            `Warning: serving cached knowledge (network unavailable, cached ${formatAge(getAge(cached2))} ago)
 `
           );
-          knowledgeData = cached.data;
+          knowledgeData = cached2.data;
           cacheHit = true;
         } else {
           throw fetchError;
@@ -2316,6 +2320,53 @@ async function actionsExecuteCommand(platform, actionId, connectionKey, options)
     const pathVariables = options.pathVars ? parseJsonArg(options.pathVars, "--path-vars") : void 0;
     const queryParams = options.queryParams ? parseJsonArg(options.queryParams, "--query-params") : void 0;
     const headers = options.headers ? parseJsonArg(options.headers, "--headers") : void 0;
+    if (!options.skipValidation) {
+      const validation = validateActionInput(actionDetails, { data, pathVariables, queryParams });
+      if (!validation.valid) {
+        spinner5.stop("Validation failed");
+        if (isAgentMode()) {
+          json({
+            error: "Validation failed: missing required parameters",
+            validation: { missing: validation.missing },
+            hint: "Add the missing parameters, or pass --skip-validation to bypass this check."
+          });
+          process.exit(1);
+        }
+        console.log();
+        for (const m of validation.missing) {
+          console.log(pc6.red(`  ${m.flag} is missing "${m.param}"`));
+          if (m.description) {
+            console.log(pc6.dim(`    ${m.description}`));
+          }
+        }
+        console.log();
+        error("Validation failed: missing required parameters. Pass --skip-validation to bypass.");
+      }
+    }
+    if (options.mock) {
+      spinner5.stop("Mock \u2014 returning example response");
+      const mockResponse = actionDetails.ioSchema?.ioExample?.output ?? null;
+      if (isAgentMode()) {
+        json({
+          mock: true,
+          request: {
+            method: actionDetails.method,
+            url: actionDetails.path
+          },
+          response: mockResponse,
+          ...mockResponse === null ? { message: "No example output available for this action" } : {}
+        });
+        return;
+      }
+      console.log();
+      if (mockResponse) {
+        console.log(pc6.bold("Mock Response:"));
+        console.log(JSON.stringify(mockResponse, null, 2));
+      } else {
+        note2("No example output available for this action", "Mock");
+      }
+      return;
+    }
     const execSpinner = createSpinner();
     execSpinner.start(options.dryRun ? "Building request..." : "Executing action...");
     const result = await api.executePassthroughRequest(
@@ -2374,6 +2425,293 @@ async function actionsExecuteCommand(platform, actionId, connectionKey, options)
     );
   }
 }
+function parseParallelSegments() {
+  const argv = process.argv.slice(2);
+  let execIdx = -1;
+  for (let i = 0; i < argv.length; i++) {
+    if ((argv[i] === "execute" || argv[i] === "x") && i > 0 && (argv[i - 1] === "actions" || argv[i - 1] === "a")) {
+      execIdx = i;
+      break;
+    }
+  }
+  if (execIdx === -1) {
+    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 cleaned = [];
+  for (let i = 0; i < raw.length; i++) {
+    const t = raw[i];
+    if (t === "--parallel" || t === "--agent") continue;
+    if (t === "--dry-run") {
+      flags.dryRun = true;
+      continue;
+    }
+    if (t === "--mock") {
+      flags.mock = true;
+      continue;
+    }
+    if (t === "--skip-validation") {
+      flags.skipValidation = true;
+      continue;
+    }
+    if (t === "--max-concurrency") {
+      flags.maxConcurrency = parseInt(raw[++i], 10) || 5;
+      continue;
+    }
+    cleaned.push(t);
+  }
+  const segmentArrays = [];
+  let current = [];
+  for (const token of cleaned) {
+    if (token === "--") {
+      if (current.length > 0) segmentArrays.push(current);
+      current = [];
+    } else {
+      current.push(token);
+    }
+  }
+  if (current.length > 0) segmentArrays.push(current);
+  if (segmentArrays.length === 0) {
+    error("--parallel requires at least one action segment. Usage: --parallel <platform> <actionId> <connectionKey> [-d ...] [-- <next action> ...]");
+  }
+  const segments = segmentArrays.map((tokens, i) => parseSegmentTokens(tokens, i + 1));
+  return { segments, flags };
+}
+function parseSegmentTokens(tokens, segmentIndex) {
+  if (tokens.length < 3) {
+    error(`Segment ${segmentIndex}: expected <platform> <actionId> <connectionKey>, got ${tokens.length} token(s): ${tokens.join(" ")}`);
+  }
+  const segment = {
+    platform: tokens[0],
+    actionId: tokens[1],
+    connectionKey: tokens[2]
+  };
+  for (let i = 3; i < tokens.length; i++) {
+    const t = tokens[i];
+    if (t === "-d" || t === "--data") {
+      segment.data = tokens[++i];
+      continue;
+    }
+    if (t === "--path-vars") {
+      segment.pathVars = tokens[++i];
+      continue;
+    }
+    if (t === "--query-params") {
+      segment.queryParams = tokens[++i];
+      continue;
+    }
+    if (t === "--headers") {
+      segment.headers = tokens[++i];
+      continue;
+    }
+    if (t === "--form-data") {
+      segment.formData = true;
+      continue;
+    }
+    if (t === "--form-url-encoded") {
+      segment.formUrlEncoded = true;
+      continue;
+    }
+    error(`Segment ${segmentIndex}: unknown option "${t}"`);
+  }
+  return segment;
+}
+function tryParseJson(value, label) {
+  try {
+    return { value: JSON.parse(value) };
+  } catch {
+    return { error: `Invalid JSON for ${label}: ${value}` };
+  }
+}
+async function actionsExecuteParallelCommand() {
+  const { segments, flags } = parseParallelSegments();
+  const { apiKey, permissions, actionIds, connectionKeys, knowledgeAgent } = getConfig();
+  if (knowledgeAgent) {
+    error("Action execution is disabled (knowledge-only mode).");
+  }
+  const api = new OneApi(apiKey, getApiBase());
+  const prepared = [];
+  const errors = [];
+  for (let i = 0; i < segments.length; i++) {
+    const seg = segments[i];
+    const label = `${seg.platform}/${seg.actionId}`;
+    const segErrors = [];
+    if (!isActionAllowed(seg.actionId, actionIds)) {
+      segErrors.push(`Action "${seg.actionId}" is not in the allowed action list`);
+    }
+    if (!connectionKeys.includes("*") && !connectionKeys.includes(seg.connectionKey)) {
+      segErrors.push(`Connection key "${seg.connectionKey}" is not allowed`);
+    }
+    let actionDetails;
+    try {
+      actionDetails = await api.getActionDetails(seg.actionId);
+    } catch (err) {
+      segErrors.push(`Action not found: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    if (actionDetails && !isMethodAllowed(actionDetails.method, permissions)) {
+      segErrors.push(`Method "${actionDetails.method}" not allowed under "${permissions}" permission level`);
+    }
+    let data;
+    let pathVariables;
+    let queryParams;
+    let headers;
+    if (seg.data) {
+      const r = tryParseJson(seg.data, `segment ${i + 1} --data`);
+      if (r.error) segErrors.push(r.error);
+      else data = r.value;
+    }
+    if (seg.pathVars) {
+      const r = tryParseJson(seg.pathVars, `segment ${i + 1} --path-vars`);
+      if (r.error) segErrors.push(r.error);
+      else pathVariables = r.value;
+    }
+    if (seg.queryParams) {
+      const r = tryParseJson(seg.queryParams, `segment ${i + 1} --query-params`);
+      if (r.error) segErrors.push(r.error);
+      else queryParams = r.value;
+    }
+    if (seg.headers) {
+      const r = tryParseJson(seg.headers, `segment ${i + 1} --headers`);
+      if (r.error) segErrors.push(r.error);
+      else headers = r.value;
+    }
+    if (actionDetails && !flags.skipValidation && segErrors.length === 0) {
+      const validation = validateActionInput(actionDetails, { data, pathVariables, queryParams });
+      if (!validation.valid) {
+        for (const m of validation.missing) {
+          segErrors.push(`Missing ${m.flag} "${m.param}"${m.description ? ` \u2014 ${m.description}` : ""}`);
+        }
+      }
+    }
+    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 });
+    }
+  }
+  if (errors.length > 0) {
+    if (isAgentMode()) {
+      json({ error: "Validation failed", segments: errors });
+      process.exit(1);
+    }
+    console.log();
+    for (const e of errors) {
+      console.log(`  ${pc6.red("\u2717")} Segment ${e.segment} (${e.label}):`);
+      for (const msg of e.messages) {
+        console.log(`    ${msg}`);
+      }
+    }
+    console.log();
+    error(`Validation failed for ${errors.length} segment(s). Fix errors above before executing.`);
+  }
+  const total = prepared.length;
+  const overallStart = Date.now();
+  const results = [];
+  for (let i = 0; i < total; i += flags.maxConcurrency) {
+    const batch = prepared.slice(i, i + flags.maxConcurrency);
+    const settled = await Promise.allSettled(
+      batch.map(async (action) => {
+        const start = Date.now();
+        const seg = action.segment;
+        const segIdx = action.index + 1;
+        if (flags.mock) {
+          const mockResponse = action.actionDetails.ioSchema?.ioExample?.output ?? null;
+          return {
+            segment: segIdx,
+            platform: seg.platform,
+            actionId: seg.actionId,
+            status: "success",
+            durationMs: Date.now() - start,
+            mock: true,
+            request: { method: action.actionDetails.method, url: action.actionDetails.path },
+            response: mockResponse
+          };
+        }
+        const result = await api.executePassthroughRequest({
+          platform: seg.platform,
+          actionId: seg.actionId,
+          connectionKey: seg.connectionKey,
+          data: action.data,
+          pathVariables: action.pathVariables,
+          queryParams: action.queryParams,
+          headers: action.headers,
+          isFormData: seg.formData,
+          isFormUrlEncoded: seg.formUrlEncoded,
+          dryRun: flags.dryRun
+        }, action.actionDetails);
+        return {
+          segment: segIdx,
+          platform: seg.platform,
+          actionId: seg.actionId,
+          status: "success",
+          durationMs: Date.now() - start,
+          dryRun: flags.dryRun || void 0,
+          request: {
+            method: result.requestConfig.method,
+            url: result.requestConfig.url,
+            ...flags.dryRun ? { headers: result.requestConfig.headers, data: result.requestConfig.data } : {}
+          },
+          response: flags.dryRun ? void 0 : result.responseData
+        };
+      })
+    );
+    for (const s of settled) {
+      if (s.status === "fulfilled") {
+        results.push(s.value);
+      } else {
+        const batchIdx = settled.indexOf(s);
+        const action = batch[batchIdx];
+        results.push({
+          segment: action.index + 1,
+          platform: action.segment.platform,
+          actionId: action.segment.actionId,
+          status: "error",
+          durationMs: 0,
+          error: s.reason instanceof Error ? s.reason.message : String(s.reason)
+        });
+      }
+    }
+  }
+  const totalDurationMs = Date.now() - overallStart;
+  const succeeded = results.filter((r) => r.status === "success").length;
+  const failed = results.filter((r) => r.status === "error").length;
+  if (isAgentMode()) {
+    json({
+      parallel: true,
+      totalDurationMs,
+      succeeded,
+      failed,
+      results
+    });
+    if (failed > 0) process.exit(1);
+    return;
+  }
+  console.log();
+  for (const r of results) {
+    const label = `${r.platform}/${r.actionId}`;
+    const time = pc6.dim(`(${(r.durationMs / 1e3).toFixed(2)}s)`);
+    if (r.mock) {
+      console.log(`  [${r.segment}/${total}] ${label} ${pc6.cyan("\u25C7 mock")} ${time}`);
+      if (r.response) console.log(`  ${pc6.dim(JSON.stringify(r.response, null, 2).split("\n").join("\n  "))}`);
+    } else if (r.dryRun) {
+      console.log(`  [${r.segment}/${total}] ${label} ${pc6.yellow("\u2298 dry-run")} ${time}`);
+    } else if (r.status === "success") {
+      console.log(`  [${r.segment}/${total}] ${label} ${pc6.green("\u2713")} ${time}`);
+      if (r.response) console.log(`  ${pc6.dim(JSON.stringify(r.response, null, 2).split("\n").join("\n  "))}`);
+    } else {
+      console.log(`  [${r.segment}/${total}] ${label} ${pc6.red("\u2717")} ${time} \u2014 ${r.error}`);
+    }
+  }
+  console.log();
+  const tag = flags.mock ? "mock" : flags.dryRun ? "dry-run" : void 0;
+  if (tag) {
+    console.log(`  Summary: ${total} ${tag} (${(totalDurationMs / 1e3).toFixed(2)}s total)`);
+  } else {
+    console.log(`  Summary: ${succeeded} succeeded, ${failed} failed (${(totalDurationMs / 1e3).toFixed(2)}s total)`);
+  }
+  console.log();
+}
 function colorMethod(method) {
   switch (method.toUpperCase()) {
     case "GET":
@@ -2461,32 +2799,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 path8 = `${pathPrefix}[${i}]`;
+    const path16 = `${pathPrefix}[${i}]`;
     if (!step || typeof step !== "object" || Array.isArray(step)) {
-      errors.push({ path: path8, message: "Step must be an object" });
+      errors.push({ path: path16, message: "Step must be an object" });
       continue;
     }
     const s = step;
     if (!s.id || typeof s.id !== "string") {
-      errors.push({ path: `${path8}.id`, message: 'Step must have a string "id"' });
+      errors.push({ path: `${path16}.id`, message: 'Step must have a string "id"' });
     }
     if (!s.name || typeof s.name !== "string") {
-      errors.push({ path: `${path8}.name`, message: 'Step must have a string "name"' });
+      errors.push({ path: `${path16}.name`, message: 'Step must have a string "name"' });
     }
     if (!s.type || !validTypes.includes(s.type)) {
-      errors.push({ path: `${path8}.type`, message: `Step type must be one of: ${validTypes.join(", ")}` });
+      errors.push({ path: `${path16}.type`, message: `Step type must be one of: ${validTypes.join(", ")}` });
       continue;
     }
     if (s.requires !== void 0) {
       if (!Array.isArray(s.requires)) {
-        errors.push({ path: `${path8}.requires`, message: '"requires" must be an array of selector strings (e.g. ["$.steps.foo.output.bar"])' });
+        errors.push({ path: `${path16}.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: `${path8}.requires[${r}]`, message: '"requires" entry must be a selector string' });
+            errors.push({ path: `${path16}.requires[${r}]`, message: '"requires" entry must be a selector string' });
           } else if (!sel.startsWith("$.")) {
-            errors.push({ path: `${path8}.requires[${r}]`, message: `"requires" entry "${sel}" must be a selector starting with "$." (e.g. "$.steps.foo.output.bar")` });
+            errors.push({ path: `${path16}.requires[${r}]`, message: `"requires" entry "${sel}" must be a selector starting with "$." (e.g. "$.steps.foo.output.bar")` });
           }
         }
       }
@@ -2494,7 +2832,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: `${path8}.onError.strategy`, message: `Error strategy must be one of: ${FLOW_SCHEMA.errorStrategies.join(", ")}` });
+        errors.push({ path: `${path16}.onError.strategy`, message: `Error strategy must be one of: ${FLOW_SCHEMA.errorStrategies.join(", ")}` });
       }
     }
     const descriptor = getStepTypeDescriptor(s.type);
@@ -2504,14 +2842,14 @@ function validateStepsArray(steps, pathPrefix, errors) {
     if (!configObj || typeof configObj !== "object") {
       const hint = detectFlatConfigHint(s, descriptor);
       errors.push({
-        path: `${path8}.${configKey}`,
+        path: `${path16}.${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 = `${path8}.${configKey}.${fieldName}`;
+      const fieldPath = `${path16}.${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}"` });
@@ -2547,24 +2885,24 @@ function validateStepsArray(steps, pathPrefix, errors) {
       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: `${path8}.${configKey}`, message: 'Code step must define either "source" (inline JS) or "module" (path to .mjs file)' });
+        errors.push({ path: `${path16}.${configKey}`, message: 'Code step must define either "source" (inline JS) or "module" (path to .mjs file)' });
       } else if (hasSource && hasModule) {
-        errors.push({ path: `${path8}.${configKey}`, message: 'Code step cannot define both "source" and "module" \u2014 pick one' });
+        errors.push({ path: `${path16}.${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: `${path8}.${configKey}.module`, message: "Code module path must be relative to the flow folder (no absolute paths)" });
+          errors.push({ path: `${path16}.${configKey}.module`, message: "Code module path must be relative to the flow folder (no absolute paths)" });
         } else if (m.split(/[\\/]/).includes("..")) {
-          errors.push({ path: `${path8}.${configKey}.module`, message: 'Code module path must not escape the flow folder ("..")' });
+          errors.push({ path: `${path16}.${configKey}.module`, message: 'Code module path must not escape the flow folder ("..")' });
         } else if (!m.endsWith(".mjs")) {
-          errors.push({ path: `${path8}.${configKey}.module`, message: "Code module must be a .mjs file" });
+          errors.push({ path: `${path16}.${configKey}.module`, message: "Code module must be a .mjs file" });
         }
       }
       if (hasSource) {
         const syntaxError = checkCodeSourceSyntax(config2.source);
         if (syntaxError) {
-          errors.push({ path: `${path8}.${configKey}.source`, message: `Syntax error in code step: ${syntaxError}` });
+          errors.push({ path: `${path16}.${configKey}.source`, message: `Syntax error in code step: ${syntaxError}` });
         }
       }
     }
@@ -2599,16 +2937,16 @@ function validateStepIds(flow2) {
   function collectIds(steps, pathPrefix) {
     for (let i = 0; i < steps.length; i++) {
       const step = steps[i];
-      const path8 = `${pathPrefix}[${i}]`;
+      const path16 = `${pathPrefix}[${i}]`;
       if (seen.has(step.id)) {
-        errors.push({ path: `${path8}.id`, message: `Duplicate step ID: "${step.id}"` });
+        errors.push({ path: `${path16}.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], `${path8}.${configKey}.${fieldName}`);
+          collectIds(config2[fieldName], `${path16}.${configKey}.${fieldName}`);
         }
       }
     }
@@ -2656,7 +2994,7 @@ function validateSelectorReferences(flow2) {
     }
     return selectors;
   }
-  function checkSelectors(selectors, path8, precedingStepIds) {
+  function checkSelectors(selectors, path16, precedingStepIds) {
     for (const selector of selectors) {
       const parts = selector.split(".");
       if (parts.length < 3) continue;
@@ -2664,15 +3002,15 @@ function validateSelectorReferences(flow2) {
       if (root === "input") {
         const inputName = parts[2];
         if (!inputNames.has(inputName)) {
-          errors.push({ path: path8, message: `Selector "${selector}" references undefined input "${inputName}"` });
+          errors.push({ path: path16, 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: path8, message: `Selector "${selector}" references undefined step "${stepId}"` });
+          errors.push({ path: path16, message: `Selector "${selector}" references undefined step "${stepId}"` });
         } else if (precedingStepIds && !precedingStepIds.has(stepId)) {
           errors.push({
-            path: path8,
+            path: path16,
             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.`
           });
         }
@@ -2680,20 +3018,20 @@ function validateSelectorReferences(flow2) {
     }
   }
   const EXPRESSION_FIELDS = /* @__PURE__ */ new Set(["condition.expression", "while.condition"]);
-  function checkOperatorsInSelectorField(value, path8) {
+  function checkOperatorsInSelectorField(value, path16) {
     if (typeof value === "string" && value.startsWith("$.")) {
       if (value.includes("||")) {
-        errors.push({ path: path8, 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: path16, 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: path8, 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: path16, 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, `${path8}.${k}`);
+        checkOperatorsInSelectorField(v, `${path16}.${k}`);
       }
     } else if (Array.isArray(value)) {
       for (let i = 0; i < value.length; i++) {
-        checkOperatorsInSelectorField(value[i], `${path8}[${i}]`);
+        checkOperatorsInSelectorField(value[i], `${path16}[${i}]`);
       }
     }
   }
@@ -2761,10 +3099,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, path8) {
+function walkOutputSchema(schema, path16) {
   let current = schema;
-  for (let i = 0; i < path8.length; i++) {
-    const seg = path8[i];
+  for (let i = 0; i < path16.length; i++) {
+    const seg = path16[i];
     if (typeof current === "string") {
       return current === "unknown" || current === "object" || current === "array" ? "opaque" : "opaque";
     }
@@ -3132,6 +3470,7 @@ ${pc7.yellow("Pausing after current step completes...")} (run ID: ${runId})`);
       mock: options.mock,
       verbose: options.verbose,
       allowBash: options.allowBash,
+      skipValidation: options.skipValidation,
       rootDir,
       onEvent
     });
@@ -3900,138 +4239,3326 @@ async function relayEventTypesCommand(platform) {
   }
 }
 
-// src/commands/cache.ts
-import pc9 from "picocolors";
-async function cacheClearCommand(actionId) {
-  if (actionId) {
-    const deleted = clearEntry(actionId);
-    if (isAgentMode()) {
-      json({ cleared: deleted, actionId });
-      return;
-    }
-    if (deleted) {
-      console.log(`Cleared cache for ${pc9.cyan(actionId)}`);
-    } else {
-      console.log(`No cache entry found for ${pc9.dim(actionId)}`);
-    }
-  } else {
-    const count = clearAll();
-    if (isAgentMode()) {
-      json({ cleared: true, count });
-      return;
-    }
-    console.log(`Cleared ${count} cached ${count === 1 ? "entry" : "entries"}`);
-  }
-}
-async function cacheListCommand(options) {
-  const entries = listCacheEntries();
-  const filtered = options.expired ? entries.filter((e) => !isFresh(e.entry)) : entries;
-  if (isAgentMode()) {
-    json({
-      entries: filtered.map((e) => ({
-        type: e.type,
-        key: e.entry.key,
-        cachedAt: e.entry.cachedAt,
-        age: formatAge(getAge(e.entry)),
-        ttl: e.entry.ttl,
-        fresh: isFresh(e.entry),
-        etag: e.entry.etag,
-        path: e.filePath
-      }))
+// src/lib/sync/models.ts
+function parseActionType(actionKey) {
+  const parts = actionKey.split("::");
+  if (parts.length < 5) return null;
+  return parts[4];
+}
+async function discoverModels(api, platform) {
+  const actions2 = await api.listAvailableActions(platform);
+  const listActionTypes = /* @__PURE__ */ new Set(["get_many", "list", "get_all"]);
+  const modelMap = /* @__PURE__ */ new Map();
+  for (const action of actions2) {
+    const actionType = parseActionType(action.key);
+    if (!actionType) continue;
+    if (!listActionTypes.has(actionType)) continue;
+    const modelName = action.modelName;
+    if (!modelName) continue;
+    if (modelMap.has(modelName)) {
+      const existing = modelMap.get(modelName);
+      const existingType = parseActionType(existing.listAction.actionId);
+      if (existingType === "get_many") continue;
+    }
+    modelMap.set(modelName, {
+      name: modelName,
+      displayName: action.title,
+      listAction: {
+        actionId: action.key,
+        path: action.path,
+        method: action.method
+      }
     });
-    return;
-  }
-  if (filtered.length === 0) {
-    console.log(options.expired ? "No expired cache entries" : "No cached entries");
-    return;
   }
-  const rows = filtered.map((e) => ({
-    type: e.type,
-    key: e.entry.key,
-    age: formatAge(getAge(e.entry)),
-    status: isFresh(e.entry) ? pc9.green("fresh") : pc9.yellow("expired")
-  }));
-  printTable(
-    [
-      { key: "type", label: "Type" },
-      { key: "key", label: "Key" },
-      { key: "age", label: "Age" },
-      { key: "status", label: "Status" }
-    ],
-    rows
+  const models = Array.from(modelMap.values());
+  await Promise.all(
+    models.map(async (model) => {
+      try {
+        const searchResults = await api.searchActions(platform, model.displayName, "execute");
+        const resolved = searchResults.find(
+          (a) => a.path === model.listAction.path && a.method === model.listAction.method
+        );
+        if (resolved?.systemId) {
+          model.listAction.actionId = resolved.systemId;
+        }
+      } catch {
+      }
+    })
   );
+  return models.sort((a, b) => a.name.localeCompare(b.name));
 }
-async function cacheUpdateAllCommand() {
-  const apiKey = getApiKey();
-  if (!apiKey) {
-    error("Not configured. Run `one init` first.");
+
+// src/lib/sync/profile.ts
+import fs8 from "fs";
+import path8 from "path";
+var PROFILES_DIR = path8.join(".one", "sync", "profiles");
+function profilePath(platform, model) {
+  return path8.join(PROFILES_DIR, `${platform}_${model}.json`);
+}
+function readProfile(platform, model) {
+  const filePath = profilePath(platform, model);
+  try {
+    if (!fs8.existsSync(filePath)) return null;
+    const raw = fs8.readFileSync(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
   }
-  const api = new OneApi(apiKey, getApiBase());
-  const entries = listCacheEntries();
-  if (entries.length === 0) {
-    if (isAgentMode()) {
-      json({ updated: 0, failed: 0, entries: [] });
-      return;
+}
+function writeProfile(profile) {
+  const required = ["platform", "model", "connectionKey", "actionId", "resultsPath", "idField", "pagination"];
+  for (const field of required) {
+    if (!profile[field]) {
+      throw new Error(`Missing required field: ${field}`);
     }
-    console.log("No cached entries to update");
-    return;
   }
-  const spinner5 = createSpinner();
-  spinner5.start(`Updating ${entries.length} cached ${entries.length === 1 ? "entry" : "entries"}...`);
-  let updated = 0;
-  let failed = 0;
-  const errors = [];
-  for (const e of entries) {
+  if (!profile.pagination.type) {
+    throw new Error("Missing required field: pagination.type");
+  }
+  fs8.mkdirSync(PROFILES_DIR, { recursive: true });
+  const filePath = profilePath(profile.platform, profile.model);
+  fs8.writeFileSync(filePath, JSON.stringify(profile, null, 2));
+}
+function writeDraftProfile(platform, model, draft) {
+  fs8.mkdirSync(PROFILES_DIR, { recursive: true });
+  const filePath = profilePath(platform, model);
+  fs8.writeFileSync(filePath, JSON.stringify(draft, null, 2));
+}
+function listProfiles(platform) {
+  if (!fs8.existsSync(PROFILES_DIR)) return [];
+  const files = fs8.readdirSync(PROFILES_DIR).filter((f) => f.endsWith(".json"));
+  const profiles = [];
+  for (const file of files) {
     try {
-      if (e.type === "knowledge") {
-        const result = await api.getActionKnowledgeWithMeta(e.entry.key);
-        const newEntry = makeCacheEntry(e.entry.key, result.data, result.etag);
-        writeCache2(e.filePath, newEntry);
-        updated++;
-      } else {
-        const refreshed = { ...e.entry, cachedAt: (/* @__PURE__ */ new Date()).toISOString() };
-        writeCache2(e.filePath, refreshed);
-        updated++;
+      const raw = fs8.readFileSync(path8.join(PROFILES_DIR, file), "utf-8");
+      const profile = JSON.parse(raw);
+      if (!platform || profile.platform === platform) {
+        profiles.push(profile);
       }
-    } catch (err) {
-      failed++;
-      errors.push({
-        key: e.entry.key,
-        error: err instanceof Error ? err.message : "Unknown error"
-      });
+    } catch {
     }
   }
-  spinner5.stop(`Updated ${updated} ${updated === 1 ? "entry" : "entries"}${failed > 0 ? `, ${failed} failed` : ""}`);
-  if (isAgentMode()) {
-    json({ updated, failed, errors: errors.length > 0 ? errors : void 0 });
-    return;
+  return profiles;
+}
+function generateTemplate(platform, model, actionId) {
+  return {
+    platform,
+    model,
+    connectionKey: "FILL_IN",
+    actionId: actionId ?? "FILL_IN",
+    resultsPath: "FILL_IN",
+    idField: "FILL_IN",
+    pagination: {
+      type: "FILL_IN (cursor | token | offset | id | link | none)",
+      nextPath: "FILL_IN",
+      passAs: "FILL_IN (query:name | body:name | header:name)"
+    }
+    // Optional. Set to "body" for POST-body list endpoints (e.g. Notion /v1/search).
+    // limitLocation: "query",
+    // Optional. Page size param name. Set to "" to disable sending any page size.
+    // limitParam: "limit",
+    // Optional. Default page size (100).
+    // defaultLimit: 100,
+  };
+}
+
+// src/lib/sync/pagination.ts
+function parsePassAs(passAs) {
+  const colonIdx = passAs.indexOf(":");
+  if (colonIdx === -1) {
+    return { location: "query", paramName: passAs };
+  }
+  const location = passAs.slice(0, colonIdx);
+  const paramName = passAs.slice(colonIdx + 1);
+  if (location === "header") return { location: "header", paramName };
+  if (location === "body") return { location: "body", paramName };
+  return { location: "query", paramName };
+}
+function getNextPageParams(response, config2, currentPage, pageSize, records) {
+  switch (config2.type) {
+    case "cursor":
+    case "token":
+    case "link":
+      return handleCursorLike(response, config2);
+    case "offset":
+      return handleOffset(response, config2, currentPage, pageSize, records);
+    case "id":
+      return handleId(response, config2, records);
+    case "none":
+      return null;
+    default:
+      return null;
+  }
+}
+function buildParam(location, paramName, value) {
+  if (location === "header") return { headers: { [paramName]: String(value) } };
+  if (location === "body") return { bodyParams: { [paramName]: value } };
+  return { queryParams: { [paramName]: value } };
+}
+function handleCursorLike(response, config2) {
+  if (!config2.nextPath || !config2.passAs) return null;
+  const nextValue = getByDotPath(response, config2.nextPath);
+  if (nextValue === null || nextValue === void 0 || nextValue === "") return null;
+  const { location, paramName } = parsePassAs(config2.passAs);
+  return buildParam(location, paramName, nextValue);
+}
+function handleOffset(response, config2, currentPage, pageSize, records) {
+  if (records.length === 0) return null;
+  const nextOffset = (currentPage + 1) * pageSize;
+  if (config2.totalPath) {
+    const total = getByDotPath(response, config2.totalPath);
+    if (typeof total === "number" && nextOffset >= total) return null;
+  }
+  if (!config2.passAs) return null;
+  const { location, paramName } = parsePassAs(config2.passAs);
+  return buildParam(location, paramName, nextOffset);
+}
+function handleId(response, config2, records) {
+  if (records.length === 0) return null;
+  if (config2.hasMorePath) {
+    const hasMore = getByDotPath(response, config2.hasMorePath);
+    if (hasMore === false) return null;
+  }
+  const lastRecord = records[records.length - 1];
+  const idFieldName = config2.idField || "id";
+  const lastId = typeof lastRecord === "object" && lastRecord !== null ? lastRecord[idFieldName] : null;
+  if (lastId === null || lastId === void 0) return null;
+  if (!config2.passAs) return null;
+  const { location, paramName } = parsePassAs(config2.passAs);
+  return buildParam(location, paramName, lastId);
+}
+
+// src/lib/sync/state.ts
+import fs9 from "fs";
+import path9 from "path";
+var SYNC_DIR = path9.join(".one", "sync");
+var STATE_FILE = path9.join(SYNC_DIR, "sync_state.json");
+function readSyncState() {
+  try {
+    if (!fs9.existsSync(STATE_FILE)) return {};
+    const raw = fs9.readFileSync(STATE_FILE, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
   }
-  if (errors.length > 0) {
-    console.log();
-    for (const e of errors) {
-      console.log(`  ${pc9.red("\u2717")} ${e.key}: ${pc9.dim(e.error)}`);
+}
+function writeSyncState(state) {
+  fs9.mkdirSync(SYNC_DIR, { recursive: true });
+  const tmp = STATE_FILE + ".tmp";
+  fs9.writeFileSync(tmp, JSON.stringify(state, null, 2));
+  fs9.renameSync(tmp, STATE_FILE);
+}
+function getModelState(platform, model) {
+  const state = readSyncState();
+  return state[platform]?.[model] ?? null;
+}
+function updateModelState(platform, model, partial) {
+  const state = readSyncState();
+  if (!state[platform]) state[platform] = {};
+  const existing = state[platform][model] ?? {
+    lastSync: null,
+    lastCursor: null,
+    totalRecords: 0,
+    pagesProcessed: 0,
+    since: null,
+    status: "idle"
+  };
+  state[platform][model] = { ...existing, ...partial };
+  writeSyncState(state);
+}
+function removeModelState(platform, model) {
+  const state = readSyncState();
+  if (!state[platform]) return;
+  if (model) {
+    delete state[platform][model];
+    if (Object.keys(state[platform]).length === 0) {
+      delete state[platform];
     }
+  } else {
+    delete state[platform];
   }
+  writeSyncState(state);
 }
 
-// src/commands/guide.ts
-import pc10 from "picocolors";
-
-// src/lib/guide-content.ts
-var GUIDE_OVERVIEW = `# One CLI \u2014 Agent Guide
-
-## Setup
+// src/lib/sync/db.ts
+import fs10 from "fs";
+import path10 from "path";
 
-1. Run \`one init\` to configure your API key (interactive \u2014 can be global or per-project)
-2. Run \`one add <platform>\` to connect platforms via OAuth
-3. Run \`one --agent connection list\` to verify connections
+// src/lib/sync/sqlite-loader.ts
+var cached = null;
+async function loadSqlite() {
+  if (cached) return cached;
+  try {
+    const modName = "better-sqlite3";
+    const mod = await import(modName);
+    cached = mod.default;
+    return cached;
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    throw new Error(
+      `The local sync engine (better-sqlite3) is not installed.
 
-## The --agent Flag
+Install it with:
+  one sync install
 
-Always use \`--agent\` for machine-readable JSON output. It disables colors, spinners, and interactive prompts.
+Or manually:
+  npm install -g better-sqlite3
 
-\`\`\`bash
-one --agent <command>
+Underlying error: ${detail}`
+    );
+  }
+}
+async function isSqliteAvailable() {
+  try {
+    await loadSqlite();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/lib/sync/db.ts
+var DATA_DIR = path10.join(".one", "sync", "data");
+function listSyncedPlatforms() {
+  if (!fs10.existsSync(DATA_DIR)) return [];
+  return fs10.readdirSync(DATA_DIR).filter((f) => f.endsWith(".db")).map((f) => f.replace(/\.db$/, ""));
+}
+async function openDatabase(platform) {
+  const Database = await loadSqlite();
+  fs10.mkdirSync(DATA_DIR, { recursive: true });
+  const dbPath = path10.join(DATA_DIR, `${platform}.db`);
+  let db;
+  try {
+    db = new Database(dbPath);
+  } catch {
+    const backupPath = dbPath + ".bak";
+    if (fs10.existsSync(dbPath)) {
+      fs10.renameSync(dbPath, backupPath);
+      process.stderr.write(`Database corrupted, starting fresh. Backup saved at ${backupPath}
+`);
+    }
+    db = new Database(dbPath);
+  }
+  db.pragma("journal_mode = WAL");
+  db.pragma("busy_timeout = 15000");
+  db.pragma("foreign_keys = OFF");
+  return db;
+}
+function getDatabasePath(platform) {
+  return path10.join(DATA_DIR, `${platform}.db`);
+}
+function getDatabaseSize(platform) {
+  const dbPath = getDatabasePath(platform);
+  if (!fs10.existsSync(dbPath)) return "0 B";
+  const stats = fs10.statSync(dbPath);
+  const bytes = stats.size;
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function detectColumnType(value) {
+  if (value === null || value === void 0) return "TEXT";
+  if (typeof value === "string") return "TEXT";
+  if (typeof value === "boolean") return "INTEGER";
+  if (typeof value === "number") return Number.isInteger(value) ? "INTEGER" : "REAL";
+  if (typeof value === "object") return "TEXT";
+  return "TEXT";
+}
+function sanitizeTableName(name) {
+  return name.replace(/[^a-zA-Z0-9_]/g, "_");
+}
+function getTableColumns(db, model) {
+  const table = sanitizeTableName(model);
+  const rows = db.prepare(`PRAGMA table_info("${table}")`).all();
+  return rows.map((r) => ({ name: r.name, type: r.type }));
+}
+function tableExists(db, model) {
+  const table = sanitizeTableName(model);
+  const row = db.prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name=?`).get(table);
+  return !!row;
+}
+function ensureTable(db, model, firstRecord, idField) {
+  const table = sanitizeTableName(model);
+  if (tableExists(db, model)) {
+    return getTableColumns(db, model).map((c) => c.name);
+  }
+  const columns = [];
+  const colDefs = [];
+  for (const [key, value] of Object.entries(firstRecord)) {
+    const colType = detectColumnType(value);
+    colDefs.push(`"${key}" ${colType}`);
+    columns.push(key);
+  }
+  if (!columns.includes("_synced_at")) {
+    colDefs.push('"_synced_at" TEXT');
+    columns.push("_synced_at");
+  }
+  db.exec(`CREATE TABLE IF NOT EXISTS "${table}" (${colDefs.join(", ")})`);
+  const safeIdField = idField.replace(/"/g, '""');
+  db.exec(`CREATE UNIQUE INDEX IF NOT EXISTS "idx_${table}_${sanitizeTableName(idField)}" ON "${table}" ("${safeIdField}")`);
+  return columns;
+}
+function rebuildFtsIndex(db, model) {
+  const table = sanitizeTableName(model);
+  const ftsTable = `${table}_fts`;
+  const columns = getTableColumns(db, model);
+  const textCols = columns.filter((c) => c.type === "TEXT" && c.name !== "_synced_at").map((c) => c.name);
+  if (textCols.length === 0) return;
+  const quotedCols = textCols.map((c) => `"${c}"`).join(", ");
+  db.exec(`DROP TABLE IF EXISTS "${ftsTable}"`);
+  db.exec(`DROP TRIGGER IF EXISTS "${table}_ai"`);
+  db.exec(`DROP TRIGGER IF EXISTS "${table}_au"`);
+  db.exec(`CREATE VIRTUAL TABLE "${ftsTable}" USING fts5(${quotedCols})`);
+  db.exec(`INSERT INTO "${ftsTable}"(rowid, ${quotedCols}) SELECT rowid, ${quotedCols} FROM "${table}"`);
+}
+function evolveSchema(db, model, record) {
+  const table = sanitizeTableName(model);
+  const existingCols = new Set(getTableColumns(db, model).map((c) => c.name));
+  for (const [key, value] of Object.entries(record)) {
+    if (!existingCols.has(key)) {
+      const colType = detectColumnType(value);
+      db.exec(`ALTER TABLE "${table}" ADD COLUMN "${key}" ${colType}`);
+    }
+  }
+}
+function prepareValue(value) {
+  if (value === null || value === void 0) return null;
+  if (typeof value === "boolean") return value ? 1 : 0;
+  if (typeof value === "number") return value;
+  if (typeof value === "string") return value;
+  if (typeof value === "object") return JSON.stringify(value);
+  return String(value);
+}
+function upsertRecords(db, model, records, idField) {
+  if (records.length === 0) return 0;
+  const table = sanitizeTableName(model);
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const existingCols = getTableColumns(db, model).map((c) => c.name);
+  const insertMany = db.transaction((recs) => {
+    let count = 0;
+    for (const record of recs) {
+      const recordKeys = Object.keys(record);
+      const newKeys = recordKeys.filter((k) => !existingCols.includes(k));
+      if (newKeys.length > 0) {
+        for (const key of newKeys) {
+          const colType = detectColumnType(record[key]);
+          db.exec(`ALTER TABLE "${table}" ADD COLUMN "${key}" ${colType}`);
+          existingCols.push(key);
+        }
+      }
+      const fullRecord = { ...record, _synced_at: now };
+      const cols = Object.keys(fullRecord).filter((k) => existingCols.includes(k) || k === "_synced_at");
+      const quotedCols = cols.map((c) => `"${c}"`).join(", ");
+      const placeholders = cols.map(() => "?").join(", ");
+      const values = cols.map((c) => prepareValue(fullRecord[c]));
+      const safeIdField = idField.replace(/"/g, '""');
+      const updateCols = cols.filter((c) => c !== idField).map((c) => `"${c}" = excluded."${c}"`).join(", ");
+      db.prepare(
+        `INSERT INTO "${table}" (${quotedCols}) VALUES (${placeholders}) ON CONFLICT("${safeIdField}") DO UPDATE SET ${updateCols}`
+      ).run(...values);
+      count++;
+    }
+    return count;
+  });
+  return insertMany(records);
+}
+function deleteRecords(db, model, where, params) {
+  const table = sanitizeTableName(model);
+  const result = db.prepare(`DELETE FROM "${table}" WHERE ${where}`).run(...params);
+  return result.changes;
+}
+function dropTable(db, model) {
+  const table = sanitizeTableName(model);
+  db.exec(`DROP TABLE IF EXISTS "${table}_fts"`);
+  db.exec(`DROP TRIGGER IF EXISTS "${table}_ai"`);
+  db.exec(`DROP TRIGGER IF EXISTS "${table}_au"`);
+  db.exec(`DROP TABLE IF EXISTS "${table}"`);
+}
+function listTables(db) {
+  const rows = db.prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE '%_fts%' AND name NOT LIKE 'sqlite_%'`).all();
+  return rows.map((r) => r.name);
+}
+function countRecords(db, model) {
+  const table = sanitizeTableName(model);
+  if (!tableExists(db, model)) return 0;
+  const row = db.prepare(`SELECT COUNT(*) as count FROM "${table}"`).get();
+  return row.count;
+}
+function deleteDatabase(platform) {
+  const dbPath = getDatabasePath(platform);
+  if (fs10.existsSync(dbPath)) fs10.unlinkSync(dbPath);
+  if (fs10.existsSync(dbPath + "-wal")) fs10.unlinkSync(dbPath + "-wal");
+  if (fs10.existsSync(dbPath + "-shm")) fs10.unlinkSync(dbPath + "-shm");
+}
+
+// src/lib/sync/lock.ts
+import fs11 from "fs";
+import path11 from "path";
+var LOCK_DIR_REL = path11.join(".one", "sync", "locks");
+var STALE_MS = 30 * 60 * 1e3;
+function lockPath(platform, model) {
+  return path11.join(LOCK_DIR_REL, `${platform}_${model}`);
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var SyncLockError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SyncLockError";
+  }
+};
+function acquireSyncLock(platform, model) {
+  fs11.mkdirSync(LOCK_DIR_REL, { recursive: true });
+  const dir = lockPath(platform, model);
+  const pidFile = path11.join(dir, "pid");
+  try {
+    fs11.mkdirSync(dir);
+  } catch (err) {
+    const stat = (() => {
+      try {
+        return fs11.statSync(dir);
+      } catch {
+        return null;
+      }
+    })();
+    if (stat) {
+      const age = Date.now() - stat.mtimeMs;
+      let ownerPid = null;
+      try {
+        const raw = fs11.readFileSync(pidFile, "utf-8");
+        const parsed = parseInt(raw.trim(), 10);
+        if (!isNaN(parsed)) ownerPid = parsed;
+      } catch {
+      }
+      const ownerDead = ownerPid !== null && !isProcessAlive(ownerPid);
+      const veryOld = age > STALE_MS;
+      if (ownerDead || veryOld) {
+        try {
+          fs11.rmSync(dir, { recursive: true, force: true });
+          fs11.mkdirSync(dir);
+        } catch {
+          throw new SyncLockError(
+            `Could not take over stale lock at ${dir}. Remove it manually if no sync is running.`
+          );
+        }
+      } else {
+        const ownerMsg = ownerPid !== null ? ` (held by pid ${ownerPid})` : "";
+        throw new SyncLockError(
+          `Another sync for ${platform}/${model} is already running${ownerMsg}. Wait for it to finish, or remove ${dir} manually if you're sure it's stale.`
+        );
+      }
+    } else {
+      throw new SyncLockError(`Failed to acquire sync lock: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+  try {
+    fs11.writeFileSync(pidFile, String(process.pid));
+  } catch {
+  }
+  return {
+    release() {
+      try {
+        fs11.rmSync(dir, { recursive: true, force: true });
+      } catch {
+      }
+    }
+  };
+}
+
+// src/lib/sync/hooks.ts
+import { spawn as spawn2 } from "child_process";
+import fs12 from "fs";
+import path12 from "path";
+var EVENTS_DIR = path12.join(".one", "sync", "events");
+function classifyRecords(db, model, records, idField, tableExists2) {
+  if (!tableExists2 || records.length === 0) {
+    return { inserts: records, updates: [] };
+  }
+  const safeTable = model.replace(/[^a-zA-Z0-9_]/g, "_");
+  const safeIdField = idField.replace(/"/g, '""');
+  const ids = records.map((r) => r[idField]).filter((id) => id !== void 0 && id !== null);
+  if (ids.length === 0) return { inserts: records, updates: [] };
+  const CHUNK = 500;
+  const existingIds = /* @__PURE__ */ new Set();
+  for (let i = 0; i < ids.length; i += CHUNK) {
+    const chunk = ids.slice(i, i + CHUNK);
+    const placeholders = chunk.map(() => "?").join(",");
+    const rows = db.prepare(
+      `SELECT "${safeIdField}" as id FROM "${safeTable}" WHERE "${safeIdField}" IN (${placeholders})`
+    ).all(...chunk);
+    for (const row of rows) existingIds.add(row.id);
+  }
+  const inserts = [];
+  const updates = [];
+  for (const record of records) {
+    const id = record[idField];
+    if (typeof id === "string" || typeof id === "number") {
+      if (existingIds.has(id)) {
+        updates.push(record);
+      } else {
+        inserts.push(record);
+      }
+    } else {
+      inserts.push(record);
+    }
+  }
+  return { inserts, updates };
+}
+async function fireHooks(hookCommand, events) {
+  if (events.length === 0) return;
+  if (hookCommand === "log") {
+    appendEventLog(events);
+    return;
+  }
+  await runShellHook(hookCommand, events);
+}
+function appendEventLog(events) {
+  if (events.length === 0) return;
+  const { platform, model } = events[0];
+  fs12.mkdirSync(EVENTS_DIR, { recursive: true });
+  const logPath = path12.join(EVENTS_DIR, `${platform}_${model}.jsonl`);
+  const lines = events.map((e) => JSON.stringify(e)).join("\n") + "\n";
+  fs12.appendFileSync(logPath, lines);
+}
+function runShellHook(command, events) {
+  return new Promise((resolve) => {
+    const input = events.map((e) => JSON.stringify(e)).join("\n") + "\n";
+    const child = spawn2("sh", ["-c", command], {
+      stdio: ["pipe", "ignore", "ignore"]
+    });
+    child.stdin.write(input);
+    child.stdin.end();
+    child.on("exit", () => resolve());
+    child.on("error", () => resolve());
+    setTimeout(() => {
+      try {
+        child.kill();
+      } catch {
+      }
+      resolve();
+    }, 3e4);
+  });
+}
+
+// src/lib/sync/enrich.ts
+var DEFAULT_CONCURRENCY = 5;
+var MAX_RETRIES = 3;
+var BASE_BACKOFF_MS = 2e3;
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function interpolate(template, record) {
+  return template.replace(/\{?\{(\w+(?:\.\w+)*)\}\}?/g, (_, path16) => {
+    const parts = path16.split(".");
+    let value = record;
+    for (const part of parts) {
+      if (typeof value !== "object" || value === null) return "";
+      value = value[part];
+    }
+    return value === null || value === void 0 ? "" : String(value);
+  });
+}
+function interpolateParams(template, record) {
+  if (!template) return void 0;
+  const out = {};
+  for (const [key, value] of Object.entries(template)) {
+    out[key] = typeof value === "string" ? interpolate(value, record) : value;
+  }
+  return out;
+}
+function deepMerge(target, source) {
+  const result = { ...target };
+  for (const [key, value] of Object.entries(source)) {
+    if (value !== null && typeof value === "object" && !Array.isArray(value) && typeof result[key] === "object" && result[key] !== null && !Array.isArray(result[key])) {
+      result[key] = deepMerge(result[key], value);
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function getByDotPath2(obj, path16) {
+  const parts = path16.split(".");
+  let current = obj;
+  for (const part of parts) {
+    if (current === null || current === void 0 || typeof current !== "object") return void 0;
+    current = current[part];
+  }
+  return current;
+}
+function stripExcludedFields(obj, paths) {
+  for (const path16 of paths) {
+    stripOnePath(obj, path16.replace(/\[\]/g, ".*").split("."));
+  }
+}
+function stripOnePath(obj, parts) {
+  if (parts.length === 0 || !obj || typeof obj !== "object") return;
+  const [current, ...rest] = parts;
+  if (current === "*") {
+    for (const value of Object.values(obj)) {
+      if (Array.isArray(value)) {
+        for (const item of value) {
+          if (typeof item === "object" && item !== null) {
+            stripOnePath(item, rest);
+          }
+        }
+      }
+    }
+    return;
+  }
+  if (rest.length === 0) {
+    delete obj[current];
+    return;
+  }
+  const child = obj[current];
+  if (Array.isArray(child) && rest[0] === "*") {
+    for (const item of child) {
+      if (typeof item === "object" && item !== null) {
+        stripOnePath(item, rest.slice(1));
+      }
+    }
+  } else if (typeof child === "object" && child !== null && !Array.isArray(child)) {
+    stripOnePath(child, rest);
+  }
+}
+function pickFields(obj, fields) {
+  const result = {};
+  for (const field of fields) {
+    const value = getByDotPath2(obj, field);
+    if (value !== void 0) result[field] = value;
+  }
+  return result;
+}
+async function enrichPhase(api, db, config2, model, idField, connectionKey, platform) {
+  const startTime = Date.now();
+  const tsField = config2.timestampField ?? "_enriched_at";
+  const safeTable = model.replace(/[^a-zA-Z0-9_]/g, "_");
+  const safeIdField = idField.replace(/"/g, '""');
+  const cols = db.prepare(`PRAGMA table_info("${safeTable}")`).all();
+  if (!cols.some((c) => c.name === tsField)) {
+    db.exec(`ALTER TABLE "${safeTable}" ADD COLUMN "${tsField}" TEXT`);
+  }
+  const unenriched = db.prepare(
+    `SELECT * FROM "${safeTable}" WHERE "${tsField}" IS NULL`
+  ).all();
+  const total = unenriched.length;
+  if (total === 0) {
+    return { enriched: 0, skipped: 0, rateLimited: 0, total: 0, duration: "0s" };
+  }
+  for (const row of unenriched) {
+    for (const [key, value] of Object.entries(row)) {
+      if (typeof value === "string" && (value.startsWith("{") || value.startsWith("["))) {
+        try {
+          row[key] = JSON.parse(value);
+        } catch {
+        }
+      }
+    }
+  }
+  let detailAction;
+  try {
+    detailAction = await api.getActionDetails(config2.actionId);
+  } catch (err) {
+    throw new Error(
+      `Enrich: could not load action ${config2.actionId}: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  let concurrency = config2.concurrency ?? DEFAULT_CONCURRENCY;
+  let enriched = 0;
+  let skipped = 0;
+  let rateLimited = 0;
+  for (let i = 0; i < unenriched.length; i += concurrency) {
+    const batch = unenriched.slice(i, i + concurrency);
+    if (!isAgentMode()) {
+      process.stderr.write(`  Enriching ${platform}/${model}... ${i}/${total}\r`);
+    }
+    const results = await Promise.allSettled(
+      batch.map((row) => enrichSingleRow(api, detailAction, config2, row, connectionKey, platform))
+    );
+    let batchHitRateLimit = false;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    for (let j = 0; j < results.length; j++) {
+      const result = results[j];
+      const row = batch[j];
+      const id = row[idField];
+      if (result.status === "fulfilled" && result.value !== null) {
+        let enrichedData = result.value;
+        if (config2.fields && config2.fields.length > 0) {
+          enrichedData = pickFields(enrichedData, config2.fields);
+        }
+        if (config2.exclude && config2.exclude.length > 0) {
+          stripExcludedFields(enrichedData, config2.exclude);
+        }
+        const merged = config2.merge !== false ? deepMerge(row, enrichedData) : { ...enrichedData, [idField]: id };
+        merged[tsField] = now;
+        const setClauses = [];
+        const values = [];
+        for (const [key, val] of Object.entries(merged)) {
+          if (key === idField) continue;
+          setClauses.push(`"${key}" = ?`);
+          values.push(prepareValue2(val));
+        }
+        values.push(prepareValue2(id));
+        if (setClauses.length > 0) {
+          const existingCols = new Set(db.prepare(`PRAGMA table_info("${safeTable}")`).all().map((c) => c.name));
+          for (const [key, val] of Object.entries(merged)) {
+            if (!existingCols.has(key)) {
+              const colType = detectColumnType2(val);
+              db.exec(`ALTER TABLE "${safeTable}" ADD COLUMN "${key}" ${colType}`);
+              existingCols.add(key);
+            }
+          }
+          db.prepare(
+            `UPDATE "${safeTable}" SET ${setClauses.join(", ")} WHERE "${safeIdField}" = ?`
+          ).run(...values);
+        }
+        enriched++;
+      } else if (result.status === "fulfilled" && result.value === null) {
+        rateLimited++;
+        skipped++;
+        batchHitRateLimit = true;
+      } else {
+        skipped++;
+      }
+    }
+    if (batchHitRateLimit) {
+      concurrency = Math.max(1, Math.floor(concurrency / 2));
+      if (!isAgentMode()) {
+        process.stderr.write(`  Enrich: rate limited \u2014 reducing concurrency to ${concurrency}
+`);
+      }
+      await sleep(BASE_BACKOFF_MS * 4);
+    } else if (i + concurrency < unenriched.length) {
+      await sleep(config2.delayMs ?? 200);
+    }
+  }
+  if (!isAgentMode()) {
+    process.stderr.write(`  Enriching ${platform}/${model}... ${enriched}/${total} done
+`);
+  }
+  const elapsed = Date.now() - startTime;
+  const duration = elapsed < 1e3 ? `${elapsed}ms` : elapsed < 6e4 ? `${(elapsed / 1e3).toFixed(1)}s` : `${Math.floor(elapsed / 6e4)}m ${Math.floor(elapsed % 6e4 / 1e3)}s`;
+  return { enriched, skipped, rateLimited, total, duration };
+}
+async function enrichSingleRow(api, detailAction, config2, row, connectionKey, platform) {
+  const pathVars = interpolateParams(config2.pathVars, row);
+  const queryParams = interpolateParams(config2.queryParams, row);
+  const body = config2.body ? JSON.parse(interpolate(JSON.stringify(config2.body), row)) : void 0;
+  for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
+    try {
+      const result = await api.executePassthroughRequest({
+        platform,
+        actionId: config2.actionId,
+        connectionKey,
+        pathVariables: pathVars,
+        queryParams,
+        data: body
+      }, detailAction);
+      let detailData;
+      if (config2.resultsPath) {
+        const extracted = getByDotPath2(result.responseData, config2.resultsPath);
+        detailData = typeof extracted === "object" && extracted !== null && !Array.isArray(extracted) ? extracted : { _enriched: extracted };
+      } else {
+        detailData = typeof result.responseData === "object" && result.responseData !== null ? result.responseData : {};
+      }
+      return detailData;
+    } catch (err) {
+      if (err instanceof ApiError && err.status === 429) {
+        const retryAfter = err.retryAfterSeconds ?? Math.min(BASE_BACKOFF_MS / 1e3 * Math.pow(2, attempt), 60);
+        await sleep(retryAfter * 1e3);
+        if (attempt === MAX_RETRIES - 1) return null;
+        continue;
+      }
+      if (err instanceof ApiError && (err.status >= 500 && err.status <= 504)) {
+        await sleep(Math.min(3 * Math.pow(2, attempt), 20) * 1e3);
+        if (attempt === MAX_RETRIES - 1) return null;
+        continue;
+      }
+      if (err instanceof ApiError && (err.status === 401 || err.status === 403)) {
+        throw err;
+      }
+      if (attempt === MAX_RETRIES - 1) return null;
+      await sleep(BASE_BACKOFF_MS * Math.pow(2, attempt));
+    }
+  }
+  return null;
+}
+function prepareValue2(value) {
+  if (value === null || value === void 0) return null;
+  if (typeof value === "boolean") return value ? 1 : 0;
+  if (typeof value === "number") return value;
+  if (typeof value === "string") return value;
+  if (typeof value === "object") return JSON.stringify(value);
+  return String(value);
+}
+function detectColumnType2(value) {
+  if (value === null || value === void 0) return "TEXT";
+  if (typeof value === "string") return "TEXT";
+  if (typeof value === "boolean") return "INTEGER";
+  if (typeof value === "number") return Number.isInteger(value) ? "INTEGER" : "REAL";
+  if (typeof value === "object") return "TEXT";
+  return "TEXT";
+}
+
+// src/lib/sync/transform.ts
+import { spawn as spawn3 } from "child_process";
+var TRANSFORM_TIMEOUT_MS = 6e4;
+async function transformRecords(command, records) {
+  const input = JSON.stringify(records);
+  return new Promise((resolve) => {
+    const child = spawn3("sh", ["-c", command], {
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    const timer = setTimeout(() => {
+      try {
+        child.kill();
+      } catch {
+      }
+      if (!isAgentMode()) {
+        process.stderr.write(`  Transform timed out after ${TRANSFORM_TIMEOUT_MS / 1e3}s \u2014 using original records
+`);
+      }
+      resolve(null);
+    }, TRANSFORM_TIMEOUT_MS);
+    child.on("exit", (code) => {
+      clearTimeout(timer);
+      if (stderr.trim() && !isAgentMode()) {
+        process.stderr.write(`  Transform stderr: ${stderr.trim()}
+`);
+      }
+      if (code !== 0) {
+        if (!isAgentMode()) {
+          process.stderr.write(`  Transform exited with code ${code} \u2014 using original records
+`);
+        }
+        resolve(null);
+        return;
+      }
+      try {
+        const parsed = JSON.parse(stdout.trim());
+        if (!Array.isArray(parsed)) {
+          if (!isAgentMode()) {
+            process.stderr.write(`  Transform returned non-array JSON \u2014 using original records
+`);
+          }
+          resolve(null);
+          return;
+        }
+        resolve(parsed);
+      } catch {
+        if (!isAgentMode()) {
+          process.stderr.write(`  Transform returned invalid JSON \u2014 using original records
+`);
+        }
+        resolve(null);
+      }
+    });
+    child.on("error", (err) => {
+      clearTimeout(timer);
+      if (!isAgentMode()) {
+        process.stderr.write(`  Transform failed to start: ${err.message} \u2014 using original records
+`);
+      }
+      resolve(null);
+    });
+    child.stdin.write(input);
+    child.stdin.end();
+  });
+}
+
+// src/lib/sync/runner.ts
+var MAX_RETRIES_PER_PAGE = 3;
+var DEFAULT_SINCE_DAYS = 90;
+function isNetworkError(err) {
+  if (!(err instanceof Error)) return false;
+  const code = err.code;
+  if (code && ["ECONNRESET", "ETIMEDOUT", "ENOTFOUND", "ECONNREFUSED", "EPIPE", "UND_ERR_SOCKET"].includes(code)) {
+    return true;
+  }
+  const msg = err.message.toLowerCase();
+  return msg.includes("fetch failed") || msg.includes("network") || msg.includes("socket");
+}
+function truncate(str, maxLen) {
+  if (str.length <= maxLen) return str;
+  return str.slice(0, maxLen) + "\u2026(truncated)";
+}
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function stripFields(record, paths) {
+  for (const path16 of paths) {
+    stripOnePath2(record, path16.split("."));
+  }
+}
+function stripOnePath2(obj, parts) {
+  if (parts.length === 0 || !obj || typeof obj !== "object") return;
+  const current = parts[0];
+  const rest = parts.slice(1);
+  if (current.endsWith("[]")) {
+    const key = current.slice(0, -2);
+    const arr = obj[key];
+    if (Array.isArray(arr)) {
+      if (rest.length === 0) {
+        delete obj[key];
+      } else {
+        for (const item of arr) {
+          if (typeof item === "object" && item !== null) {
+            stripOnePath2(item, rest);
+          }
+        }
+      }
+    }
+    return;
+  }
+  if (rest.length === 0) {
+    delete obj[current];
+    return;
+  }
+  const child = obj[current];
+  if (typeof child === "object" && child !== null && !Array.isArray(child)) {
+    stripOnePath2(child, rest);
+  }
+}
+function parseSince(since) {
+  const durationMatch = since.match(/^(\d+)([dhm])$/);
+  if (durationMatch) {
+    const amount = parseInt(durationMatch[1], 10);
+    const unit = durationMatch[2];
+    const now = /* @__PURE__ */ new Date();
+    if (unit === "d") now.setDate(now.getDate() - amount);
+    else if (unit === "h") now.setHours(now.getHours() - amount);
+    else if (unit === "m") now.setMonth(now.getMonth() - amount);
+    return now;
+  }
+  return new Date(since);
+}
+function formatDuration(ms) {
+  if (ms < 1e3) return `${ms}ms`;
+  const seconds = ms / 1e3;
+  if (seconds < 60) return `${seconds.toFixed(1)}s`;
+  const minutes = Math.floor(seconds / 60);
+  const remainingSeconds = (seconds % 60).toFixed(0);
+  return `${minutes}m ${remainingSeconds}s`;
+}
+async function syncModel(api, profile, options) {
+  const { platform, model } = profile;
+  const startTime = Date.now();
+  if (options.fullRefresh && options.since) {
+    throw new Error(
+      "--full-refresh and --since cannot be used together. --full-refresh always fetches the whole collection."
+    );
+  }
+  const lock = options.dryRun ? null : acquireSyncLock(platform, model);
+  const existingState = getModelState(platform, model);
+  if (existingState?.status === "syncing" && !options.force) {
+    if (lock) lock.release();
+    throw new Error(
+      `Sync state says ${platform}/${model} is already syncing. Use --force to override (this may happen if a previous sync crashed before cleanup).`
+    );
+  }
+  if (!profile.dateFilter && !options.dryRun && !options.fullRefresh && !isAgentMode()) {
+    process.stderr.write(
+      `\u26A0 ${platform}/${model} profile has no dateFilter \u2014 this sync will fetch the entire collection every run. Add a dateFilter to the profile for true incremental sync, or accept the full-pull cost.
+`
+    );
+  }
+  if (!options.dryRun) {
+    updateModelState(platform, model, { status: "syncing" });
+  }
+  let db = null;
+  let totalRecords = 0;
+  let pagesProcessed = 0;
+  let lastCursor = null;
+  const seenIds = /* @__PURE__ */ new Set();
+  let hooksInserted = 0;
+  let hooksUpdated = 0;
+  const hasHooks = !!(profile.onInsert || profile.onUpdate || profile.onChange);
+  let enrichedTotal = 0;
+  let enrichSkipped = 0;
+  let enrichRateLimited = 0;
+  try {
+    db = await openDatabase(platform);
+    let sinceDate = null;
+    if (options.fullRefresh) {
+      sinceDate = null;
+    } else if (options.since) {
+      sinceDate = parseSince(options.since);
+    } else if (!options.force && existingState?.lastSync) {
+      sinceDate = new Date(existingState.lastSync);
+    } else {
+      sinceDate = /* @__PURE__ */ new Date();
+      sinceDate.setDate(sinceDate.getDate() - DEFAULT_SINCE_DAYS);
+    }
+    const queryParams = { ...profile.queryParams };
+    const bodyParams = { ...profile.body };
+    const pageSize = profile.defaultLimit ?? 100;
+    const limitLocation = profile.limitLocation || "query";
+    let limitParam;
+    if (profile.limitParam !== void 0) {
+      limitParam = profile.limitParam;
+    } else if (profile.pagination.type === "none") {
+      limitParam = "";
+    } else {
+      limitParam = "limit";
+    }
+    if (limitParam) {
+      if (limitLocation === "body") {
+        bodyParams[limitParam] = pageSize;
+      } else {
+        queryParams[limitParam] = pageSize;
+      }
+    }
+    if (sinceDate && profile.dateFilter) {
+      const { param, format } = profile.dateFilter;
+      let dateValue;
+      if (format === "iso8601") {
+        dateValue = sinceDate.toISOString();
+      } else if (format === "unix") {
+        dateValue = Math.floor(sinceDate.getTime() / 1e3);
+      } else if (format === "date") {
+        dateValue = sinceDate.toISOString().split("T")[0];
+      }
+      if (dateValue !== void 0) {
+        queryParams[param] = dateValue;
+      }
+    }
+    const actionDetails = await api.getActionDetails(profile.actionId);
+    const maxPages = options.maxPages ?? Infinity;
+    let tableCreated = tableExists(db, model);
+    let currentPageQueryParams = { ...queryParams };
+    let currentPageBodyParams = { ...bodyParams };
+    let currentPageHeaders;
+    let startPage = 0;
+    if (!options.force && !options.fullRefresh && existingState?.status === "failed" && existingState.lastCursor != null && profile.pagination.passAs) {
+      const { location, paramName } = parsePassAs(profile.pagination.passAs);
+      if (location === "header") {
+        currentPageHeaders = { ...currentPageHeaders, [paramName]: String(existingState.lastCursor) };
+      } else if (location === "body") {
+        currentPageBodyParams[paramName] = existingState.lastCursor;
+      } else {
+        currentPageQueryParams[paramName] = existingState.lastCursor;
+      }
+      startPage = existingState.pagesProcessed;
+      if (!isAgentMode()) {
+        process.stderr.write(
+          `Resuming ${platform}/${model} from page ${startPage + 1} (cursor: ${String(existingState.lastCursor).slice(0, 40)})
+`
+        );
+      }
+    }
+    for (let page = startPage; page < maxPages + startPage; page++) {
+      let responseData;
+      let retries = 0;
+      while (true) {
+        try {
+          const hasBody = Object.keys(currentPageBodyParams).length > 0;
+          const result = await api.executePassthroughRequest({
+            platform,
+            actionId: profile.actionId,
+            connectionKey: profile.connectionKey,
+            pathVariables: profile.pathVars,
+            queryParams: currentPageQueryParams,
+            headers: currentPageHeaders,
+            data: hasBody ? currentPageBodyParams : void 0
+          }, actionDetails);
+          responseData = result.responseData;
+          break;
+        } catch (err) {
+          if (err instanceof ApiError) {
+            const isRateLimited = err.status === 429;
+            const isServerError = err.status >= 500 && err.status <= 504;
+            if ((isRateLimited || isServerError) && retries < MAX_RETRIES_PER_PAGE) {
+              const retryAfter = isRateLimited ? err.retryAfterSeconds ?? Math.min(30 * Math.pow(2, retries), 120) : Math.min(5 * Math.pow(2, retries), 30);
+              const label = isRateLimited ? "Rate limited" : `Server error (${err.status})`;
+              if (!isAgentMode()) {
+                process.stderr.write(`  ${label}. Waiting ${retryAfter}s before retry (${retries + 1}/${MAX_RETRIES_PER_PAGE})...
+`);
+              }
+              await sleep2(retryAfter * 1e3);
+              retries++;
+              continue;
+            }
+            if (err.status === 401 || err.status === 403) {
+              throw new Error(`Authentication failed. Connection key may be expired. Run 'one add ${platform}' to refresh.`);
+            }
+          }
+          if (isNetworkError(err) && retries < MAX_RETRIES_PER_PAGE) {
+            const backoff = Math.min(2 * Math.pow(2, retries), 16);
+            if (!isAgentMode()) {
+              process.stderr.write(`  Network error. Retrying in ${backoff}s (${retries + 1}/${MAX_RETRIES_PER_PAGE})...
+`);
+            }
+            await sleep2(backoff * 1e3);
+            retries++;
+            continue;
+          }
+          throw err;
+        }
+      }
+      const records = getByDotPath(responseData, profile.resultsPath);
+      if (!Array.isArray(records)) {
+        const topKeys = typeof responseData === "object" && responseData !== null ? Object.keys(responseData) : [];
+        throw new Error(
+          `Could not find results at path '${profile.resultsPath}' in API response. Check your sync profile. Response keys: [${topKeys.join(", ")}]`
+        );
+      }
+      if (records.length === 0 && page === 0) {
+        if (!isAgentMode()) {
+          process.stderr.write(`No records found for ${model} with the given filters.
+`);
+        }
+        break;
+      }
+      if (records.length === 0) break;
+      if (options.dryRun) {
+        pagesProcessed = 1;
+        totalRecords = records.length;
+        db.close();
+        return {
+          model,
+          recordsSynced: totalRecords,
+          pagesProcessed,
+          duration: formatDuration(Date.now() - startTime),
+          status: "dry-run"
+        };
+      }
+      if (profile.transform) {
+        const transformed = await transformRecords(profile.transform, records);
+        if (transformed) {
+          records.length = 0;
+          for (const r of transformed) records.push(r);
+        }
+      }
+      if (profile.exclude && profile.exclude.length > 0) {
+        for (const record of records) {
+          stripFields(record, profile.exclude);
+        }
+      }
+      if (profile.identityKey) {
+        for (const record of records) {
+          const raw = getByDotPath(record, profile.identityKey);
+          if (raw !== null && raw !== void 0) {
+            record._identity = String(raw).toLowerCase().trim();
+          }
+        }
+      }
+      if (!tableCreated) {
+        const firstRecord = records[0];
+        ensureTable(db, model, firstRecord, profile.idField);
+        tableCreated = true;
+      }
+      for (const record of records) {
+        if (typeof record === "object" && record !== null) {
+          evolveSchema(db, model, record);
+          break;
+        }
+      }
+      if (options.fullRefresh) {
+        for (const rec of records) {
+          const id = rec[profile.idField];
+          if (typeof id === "string" || typeof id === "number") {
+            seenIds.add(id);
+          }
+        }
+      }
+      let inserts = [];
+      let updates = [];
+      if (hasHooks) {
+        const classified = classifyRecords(
+          db,
+          model,
+          records,
+          profile.idField,
+          tableCreated
+        );
+        inserts = classified.inserts;
+        updates = classified.updates;
+      }
+      const inserted = upsertRecords(
+        db,
+        model,
+        records,
+        profile.idField
+      );
+      totalRecords += inserted;
+      pagesProcessed++;
+      if (hasHooks) {
+        const now = (/* @__PURE__ */ new Date()).toISOString();
+        const buildEvents = (type, recs) => recs.map((record) => ({ type, platform, model, record, timestamp: now }));
+        const insertEvents = buildEvents("insert", inserts);
+        const updateEvents = buildEvents("update", updates);
+        hooksInserted += inserts.length;
+        hooksUpdated += updates.length;
+        if (inserts.length > 0 && (profile.onInsert || profile.onChange)) {
+          await fireHooks(profile.onInsert || profile.onChange, insertEvents);
+        }
+        if (updates.length > 0 && (profile.onUpdate || profile.onChange)) {
+          await fireHooks(profile.onUpdate || profile.onChange, updateEvents);
+        }
+      }
+      if (!isAgentMode()) {
+        process.stderr.write(`Syncing ${platform}/${model}... page ${pagesProcessed} (${totalRecords} records)\r`);
+      }
+      const nextParams = getNextPageParams(
+        responseData,
+        profile.pagination,
+        page,
+        pageSize,
+        records
+      );
+      const cursorBag = nextParams?.queryParams ?? nextParams?.bodyParams ?? nextParams?.headers;
+      const cursorKeys = cursorBag ? Object.keys(cursorBag) : [];
+      lastCursor = cursorKeys.length > 0 ? cursorBag[cursorKeys[0]] : null;
+      updateModelState(platform, model, {
+        totalRecords: countRecords(db, model),
+        pagesProcessed,
+        lastCursor,
+        status: "syncing"
+      });
+      if (!nextParams) break;
+      currentPageQueryParams = { ...queryParams, ...nextParams.queryParams };
+      currentPageBodyParams = { ...bodyParams, ...nextParams.bodyParams };
+      if (nextParams.headers) {
+        currentPageHeaders = { ...currentPageHeaders, ...nextParams.headers };
+      }
+    }
+    let deletedStale = 0;
+    if (options.fullRefresh && pagesProcessed > 0 && tableCreated && seenIds.size > 0) {
+      const safeTable = sanitizeTableName(model);
+      const safeIdField = profile.idField.replace(/"/g, '""');
+      const ids = Array.from(seenIds);
+      const CHUNK = 500;
+      const seenChunks = [];
+      for (let i = 0; i < ids.length; i += CHUNK) {
+        seenChunks.push(ids.slice(i, i + CHUNK));
+      }
+      db.exec(`CREATE TEMP TABLE IF NOT EXISTS _seen_ids (id)`);
+      db.exec(`DELETE FROM _seen_ids`);
+      const insertStmt = db.prepare(`INSERT INTO _seen_ids (id) VALUES (?)`);
+      const tx = db.transaction((batch) => {
+        for (const id of batch) insertStmt.run(id);
+      });
+      for (const chunk of seenChunks) tx(chunk);
+      const delResult = db.prepare(
+        `DELETE FROM "${safeTable}" WHERE "${safeIdField}" NOT IN (SELECT id FROM _seen_ids)`
+      ).run();
+      deletedStale = delResult.changes;
+      db.exec(`DROP TABLE IF EXISTS _seen_ids`);
+      if (!isAgentMode() && deletedStale > 0) {
+        process.stderr.write(`Removed ${deletedStale} stale record(s) no longer in source.
+`);
+      }
+    }
+    if (pagesProcessed > 0 && tableCreated) {
+      rebuildFtsIndex(db, model);
+    }
+    if (!isAgentMode() && pagesProcessed > 0) {
+      process.stderr.write(`Syncing ${platform}/${model}... page ${pagesProcessed} (${totalRecords} records) done
+`);
+    }
+    let enrichResult = null;
+    if (profile.enrich && tableCreated && !options.dryRun) {
+      enrichResult = await enrichPhase(
+        api,
+        db,
+        profile.enrich,
+        model,
+        profile.idField,
+        profile.connectionKey,
+        platform
+      );
+      enrichedTotal = enrichResult.enriched;
+      enrichSkipped = enrichResult.skipped;
+      enrichRateLimited = enrichResult.rateLimited;
+      if (enrichResult.enriched > 0) {
+        rebuildFtsIndex(db, model);
+      }
+    }
+    const duration = formatDuration(Date.now() - startTime);
+    const actualCount = countRecords(db, model);
+    updateModelState(platform, model, {
+      lastSync: (/* @__PURE__ */ new Date()).toISOString(),
+      totalRecords: actualCount,
+      pagesProcessed,
+      lastCursor: null,
+      since: sinceDate?.toISOString() ?? null,
+      status: "idle"
+    });
+    db.close();
+    if (lock) lock.release();
+    return {
+      model,
+      recordsSynced: totalRecords,
+      pagesProcessed,
+      duration,
+      status: "complete",
+      deletedStale,
+      ...hasHooks ? { hooksInserted, hooksUpdated } : {},
+      ...profile.enrich ? { enriched: enrichedTotal, enrichSkipped, enrichRateLimited } : {}
+    };
+  } catch (err) {
+    const failedCount = db ? countRecords(db, model) : existingState?.totalRecords ?? 0;
+    updateModelState(platform, model, {
+      status: "failed",
+      totalRecords: failedCount,
+      pagesProcessed,
+      lastCursor
+    });
+    if (db) db.close();
+    if (lock) lock.release();
+    const rawMsg = err instanceof Error ? err.message : String(err);
+    const shortMsg = truncate(rawMsg, 500);
+    if (pagesProcessed > 0) {
+      const resumeErr = new Error(
+        `Sync interrupted after page ${pagesProcessed} (${totalRecords} records). Run again to resume. Error: ${shortMsg}`
+      );
+      resumeErr._recordsSynced = totalRecords;
+      resumeErr._pagesProcessed = pagesProcessed;
+      throw resumeErr;
+    }
+    const wrapped = new Error(shortMsg);
+    wrapped._recordsSynced = totalRecords;
+    wrapped._pagesProcessed = pagesProcessed;
+    throw wrapped;
+  }
+}
+
+// src/lib/sync/test.ts
+function detectColumnType3(value) {
+  if (value === null || value === void 0) return "TEXT";
+  if (typeof value === "string") return "TEXT";
+  if (typeof value === "boolean") return "INTEGER";
+  if (typeof value === "number") return Number.isInteger(value) ? "INTEGER" : "REAL";
+  if (typeof value === "object") return "TEXT (JSON)";
+  return "TEXT";
+}
+async function testSyncProfile(api, profile) {
+  const checks = [];
+  const report = {
+    platform: profile.platform,
+    model: profile.model,
+    ok: false,
+    checks
+  };
+  const queryParams = { ...profile.queryParams };
+  const bodyParams = { ...profile.body };
+  const pageSize = profile.defaultLimit ?? 10;
+  const limitLocation = profile.limitLocation || "query";
+  let limitParam;
+  if (profile.limitParam !== void 0) {
+    limitParam = profile.limitParam;
+  } else if (profile.pagination.type === "none") {
+    limitParam = "";
+  } else {
+    limitParam = "limit";
+  }
+  if (limitParam) {
+    if (limitLocation === "body") bodyParams[limitParam] = pageSize;
+    else queryParams[limitParam] = pageSize;
+  }
+  let actionDetails;
+  try {
+    actionDetails = await api.getActionDetails(profile.actionId);
+    checks.push({ name: "action resolves", ok: true });
+  } catch (err) {
+    checks.push({
+      name: "action resolves",
+      ok: false,
+      detail: err instanceof Error ? err.message : String(err)
+    });
+    return report;
+  }
+  let responseData;
+  try {
+    const result = await api.executePassthroughRequest({
+      platform: profile.platform,
+      actionId: profile.actionId,
+      connectionKey: profile.connectionKey,
+      pathVariables: profile.pathVars,
+      queryParams,
+      data: Object.keys(bodyParams).length > 0 ? bodyParams : void 0
+    }, actionDetails);
+    responseData = result.responseData;
+    checks.push({ name: "single-page fetch", ok: true });
+  } catch (err) {
+    const detail = err instanceof ApiError ? `HTTP ${err.status}: ${err.message}` : err instanceof Error ? err.message : String(err);
+    checks.push({ name: "single-page fetch", ok: false, detail });
+    return report;
+  }
+  let resolvedResultsPath = profile.resultsPath;
+  let records = getByDotPath(responseData, resolvedResultsPath);
+  if (!Array.isArray(records) && typeof responseData === "object" && responseData !== null) {
+    const topObj = responseData;
+    const arrayKey = Object.keys(topObj).find((k) => Array.isArray(topObj[k]));
+    if (arrayKey) {
+      resolvedResultsPath = arrayKey;
+      records = topObj[arrayKey];
+      report.autoFixed = report.autoFixed ?? {};
+      report.autoFixed.resultsPath = arrayKey;
+      checks.push({
+        name: `resultsPath auto-discovered \u2192 "${arrayKey}"`,
+        ok: true,
+        detail: `Profile had "${profile.resultsPath}" which didn't resolve; found "${arrayKey}" in response`
+      });
+    }
+  }
+  if (!Array.isArray(records)) {
+    const topKeys = typeof responseData === "object" && responseData !== null ? Object.keys(responseData) : [];
+    checks.push({
+      name: `resultsPath "${resolvedResultsPath}" \u2192 array`,
+      ok: false,
+      detail: `Not an array. Response keys: [${topKeys.join(", ")}]`
+    });
+    return report;
+  }
+  checks.push({
+    name: `resultsPath "${resolvedResultsPath}" \u2192 array`,
+    ok: true,
+    detail: `${records.length} records`
+  });
+  if (records.length === 0) {
+    checks.push({ name: "sample record available", ok: false, detail: "empty result set" });
+    report.ok = checks.every((c) => c.ok === true || c.name === "sample record available");
+    return report;
+  }
+  const first = records[0];
+  let resolvedIdField = profile.idField;
+  let idValue = first[resolvedIdField];
+  if ((idValue === void 0 || idValue === null) && typeof first === "object") {
+    const idCandidates = ["id", "_id", "uuid", "ID", "Id"];
+    const found = idCandidates.find((c) => first[c] !== void 0 && first[c] !== null);
+    if (found) {
+      resolvedIdField = found;
+      idValue = first[found];
+      report.autoFixed = report.autoFixed ?? {};
+      report.autoFixed.idField = found;
+      checks.push({
+        name: `idField auto-discovered \u2192 "${found}"`,
+        ok: true,
+        detail: `Profile had "${profile.idField}" which wasn't on the record; found "${found}"`
+      });
+    }
+  }
+  if (idValue === void 0 || idValue === null) {
+    checks.push({
+      name: `idField "${resolvedIdField}" present`,
+      ok: false,
+      detail: `Not found. Available fields: [${Object.keys(first).slice(0, 20).join(", ")}]`
+    });
+  } else {
+    checks.push({
+      name: `idField "${resolvedIdField}" present`,
+      ok: true,
+      detail: `sample value: ${String(idValue).slice(0, 60)}`
+    });
+  }
+  const nextParams = getNextPageParams(responseData, profile.pagination, 0, pageSize, records);
+  if (profile.pagination.type === "none") {
+    checks.push({ name: "pagination type: none", ok: true });
+  } else if (nextParams) {
+    checks.push({
+      name: `pagination "${profile.pagination.type}" \u2192 next page`,
+      ok: true,
+      detail: JSON.stringify(nextParams).slice(0, 120)
+    });
+    report.paginationPreview = nextParams;
+  } else {
+    checks.push({
+      name: `pagination "${profile.pagination.type}"`,
+      ok: true,
+      detail: "no next page (single-page result or end-of-data)"
+    });
+  }
+  report.detectedColumns = Object.entries(first).map(([name, value]) => ({
+    name,
+    type: detectColumnType3(value)
+  }));
+  report.sample = first;
+  report.ok = checks.every((c) => c.ok);
+  return report;
+}
+
+// src/lib/sync/infer.ts
+var PAGINATION_PATTERNS = [
+  // Notion-style: start_cursor + next_cursor in body (POST endpoints)
+  {
+    match: /start_cursor|next_cursor/i,
+    config: {
+      type: "cursor",
+      nextPath: "next_cursor",
+      passAs: "body:start_cursor",
+      hasMorePath: "has_more"
+    },
+    label: "Notion-style body cursor pagination (start_cursor/next_cursor)"
+  },
+  // Stripe-style: starting_after cursor returning has_more (checked AFTER Notion so we don't match has_more alone)
+  {
+    match: /starting_after/i,
+    config: {
+      type: "id",
+      passAs: "query:starting_after",
+      hasMorePath: "has_more",
+      idField: "id"
+    },
+    label: "Stripe-style id pagination (starting_after + has_more)"
+  },
+  // Shopify/GitHub Link-header cursor
+  {
+    match: /link:\s*<[^>]+>;\s*rel="next"|page_info=/i,
+    config: { type: "link", nextPath: "headers.link", passAs: "query:page_info" },
+    label: "Link header cursor pagination"
+  },
+  // HubSpot / Google: next page token
+  {
+    match: /next_page_token|nextPageToken|paging\.next\.after/i,
+    config: {
+      type: "token",
+      nextPath: "paging.next.after",
+      passAs: "query:after"
+    },
+    label: "token/after pagination (HubSpot/Google style)"
+  },
+  // Generic cursor
+  {
+    match: /next_cursor|nextCursor|cursor/i,
+    config: { type: "cursor", nextPath: "next_cursor", passAs: "query:cursor" },
+    label: "generic cursor pagination"
+  },
+  // Offset/limit
+  {
+    match: /offset.*limit|page.*per_page/i,
+    config: { type: "offset", passAs: "query:offset" },
+    label: "offset/limit pagination"
+  }
+];
+function inferResultsPath(knowledge, modelName, platform) {
+  const candidates = ["data", "results", "items", "records", "rows", "entries"];
+  for (const key of candidates) {
+    const re = new RegExp(`"${key}"\\s*:\\s*\\[`, "i");
+    if (re.test(knowledge)) return key;
+  }
+  if (modelName) {
+    const namesToTry = /* @__PURE__ */ new Set();
+    namesToTry.add(modelName);
+    namesToTry.add(modelName.toLowerCase());
+    if (platform) {
+      const lower = modelName.toLowerCase();
+      const platLower = platform.toLowerCase().replace(/-/g, "");
+      if (lower.startsWith(platLower)) {
+        const stripped = modelName.slice(platLower.length);
+        if (stripped.length > 0) {
+          namesToTry.add(stripped[0].toLowerCase() + stripped.slice(1));
+        }
+      }
+    }
+    if (modelName.endsWith("ies")) {
+      namesToTry.add(modelName.slice(0, -3) + "y");
+    } else if (modelName.endsWith("s")) {
+      namesToTry.add(modelName.slice(0, -1));
+    } else {
+      namesToTry.add(modelName + "s");
+    }
+    for (const name of namesToTry) {
+      const reJson = new RegExp(`"${name}"\\s*:\\s*\\[`, "i");
+      const reProse = new RegExp(`\\b${name}\\b.*\\barray\\b|\\barray\\b.*\\b${name}\\b`, "i");
+      if (reJson.test(knowledge) || reProse.test(knowledge)) return name;
+    }
+  }
+  return void 0;
+}
+function inferPathVars(knowledge) {
+  const vars = {};
+  const urlMatches = knowledge.matchAll(/\{\{?([a-zA-Z_][a-zA-Z0-9_]*)\}?\}/g);
+  for (const m of urlMatches) {
+    const name = m[1];
+    if (["payload", "timestamp", "eventType", "connectionId", "relayEventId"].includes(name)) continue;
+    if (isExcludedPathVar(name)) continue;
+    vars[name] = suggestDefault(name);
+  }
+  if (Object.keys(vars).length === 0) return void 0;
+  return vars;
+}
+var INTERNAL_PATH_VARS = /* @__PURE__ */ new Set([
+  "internal_signing_key",
+  "signing_key",
+  "api_key",
+  "apikey",
+  "secret",
+  "token",
+  "access_token",
+  "refresh_token"
+]);
+var RECORD_LEVEL_PATH_VARS = /* @__PURE__ */ new Set([
+  "record_id",
+  "recordid",
+  "id",
+  "itemid",
+  "item_id",
+  "pageid",
+  "page_id",
+  "objectid",
+  "object_id",
+  "entryid",
+  "entry_id",
+  "resourceid",
+  "resource_id"
+]);
+function suggestDefault(varName) {
+  const lower = varName.toLowerCase();
+  if (lower === "calendarid") return "primary";
+  if (lower === "userid" || lower === "user_id") return "me";
+  if (lower === "accountid" || lower === "account_id") return "me";
+  return "FILL_IN";
+}
+function isExcludedPathVar(varName) {
+  const lower = varName.toLowerCase();
+  return INTERNAL_PATH_VARS.has(lower) || RECORD_LEVEL_PATH_VARS.has(lower);
+}
+function inferIdField(knowledge) {
+  if (/"id"\s*:/.test(knowledge)) return "id";
+  if (/\b_id\b/.test(knowledge)) return "_id";
+  if (/\buuid\b/i.test(knowledge)) return "uuid";
+  return void 0;
+}
+function inferDateFilter(knowledge) {
+  const candidates = ["updated_since", "updatedSince", "modified_since", "since", "updated_after", "created_after"];
+  for (const c of candidates) {
+    if (new RegExp(`\\b${c}\\b`, "i").test(knowledge)) return c;
+  }
+  return void 0;
+}
+function inferProfileFromKnowledge(knowledge, modelName, platform) {
+  const hints = { reasoning: [] };
+  if (!knowledge) {
+    hints.reasoning.push("No knowledge available; all fields left as FILL_IN.");
+    return hints;
+  }
+  for (const pattern of PAGINATION_PATTERNS) {
+    if (pattern.match.test(knowledge)) {
+      hints.pagination = { ...pattern.config };
+      if (hints.pagination.type === "offset") {
+        delete hints.pagination.nextPath;
+        delete hints.pagination.hasMorePath;
+      } else if (hints.pagination.type === "none") {
+        delete hints.pagination.nextPath;
+        delete hints.pagination.passAs;
+        delete hints.pagination.hasMorePath;
+      }
+      hints.reasoning.push(`Pagination: ${pattern.label}`);
+      break;
+    }
+  }
+  const resultsPath = inferResultsPath(knowledge, modelName, platform);
+  if (resultsPath) {
+    hints.resultsPath = resultsPath;
+    hints.reasoning.push(`resultsPath: "${resultsPath}" (found in response schema)`);
+  }
+  const idField = inferIdField(knowledge);
+  if (idField) {
+    hints.idField = idField;
+    hints.reasoning.push(`idField: "${idField}"`);
+  }
+  const dateFilter = inferDateFilter(knowledge);
+  if (dateFilter) {
+    hints.dateFilterParam = dateFilter;
+    hints.reasoning.push(`dateFilter candidate: "${dateFilter}" (for incremental sync)`);
+  }
+  const pathVars = inferPathVars(knowledge);
+  if (pathVars) {
+    hints.pathVars = pathVars;
+    const varList = Object.entries(pathVars).map(([k, v]) => v === "FILL_IN" ? k : `${k}="${v}"`).join(", ");
+    hints.reasoning.push(`pathVars: {${varList}} (extracted from URL template)`);
+  }
+  const isPost = /\bPOST\b/.test(knowledge);
+  if (isPost) {
+    const bodyLimitMatch = knowledge.match(/\b(page_size|pageSize|limit|max_results|maxResults)\b/);
+    if (bodyLimitMatch) {
+      hints.limitLocation = "body";
+      hints.limitParam = bodyLimitMatch[1];
+      hints.reasoning.push(
+        `limitLocation: "body" (POST endpoint \u2014 page size "${bodyLimitMatch[1]}" goes in request body)`
+      );
+      if (hints.pagination && hints.pagination.passAs && hints.pagination.passAs.startsWith("query:")) {
+        const paramName = hints.pagination.passAs.slice("query:".length);
+        hints.pagination.passAs = `body:${paramName}`;
+        hints.reasoning.push(`adjusted pagination passAs to "body:${paramName}" (POST endpoint)`);
+      }
+    }
+  }
+  if (hints.reasoning.length === 0) {
+    hints.reasoning.push("Could not infer any fields from knowledge \u2014 fill template manually.");
+  }
+  return hints;
+}
+
+// src/lib/sync/builtin-profiles.ts
+import fs13 from "fs";
+import path13 from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
+function getProfilesDir() {
+  const thisFile = fileURLToPath3(import.meta.url);
+  const thisDir = path13.dirname(thisFile);
+  for (let i = 1; i <= 4; i++) {
+    const candidate = path13.resolve(thisDir, ...Array(i).fill(".."), "profiles");
+    if (fs13.existsSync(candidate)) return candidate;
+  }
+  return "";
+}
+function loadBuiltinProfile(platform, model) {
+  const dir = getProfilesDir();
+  if (!dir) return null;
+  const filePath = path13.join(dir, platform, `${model}.json`);
+  try {
+    if (!fs13.existsSync(filePath)) return null;
+    const raw = fs13.readFileSync(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function listBuiltinProfiles(platform) {
+  const dir = getProfilesDir();
+  if (!dir) return [];
+  const profiles = [];
+  try {
+    const platforms = platform ? [platform] : fs13.readdirSync(dir).filter((f) => {
+      try {
+        return fs13.statSync(path13.join(dir, f)).isDirectory();
+      } catch {
+        return false;
+      }
+    });
+    for (const plat of platforms) {
+      const platDir = path13.join(dir, plat);
+      if (!fs13.existsSync(platDir)) continue;
+      const files = fs13.readdirSync(platDir).filter((f) => f.endsWith(".json"));
+      for (const file of files) {
+        try {
+          const raw = fs13.readFileSync(path13.join(platDir, file), "utf-8");
+          const profile = JSON.parse(raw);
+          profiles.push(profile);
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+  return profiles;
+}
+
+// src/lib/sync/schedule.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import fs15 from "fs";
+import os7 from "os";
+import path15 from "path";
+
+// src/lib/sync/schedule-registry.ts
+import fs14 from "fs";
+import os6 from "os";
+import path14 from "path";
+var REGISTRY_DIR = path14.join(os6.homedir(), ".one", "sync");
+var REGISTRY_FILE = path14.join(REGISTRY_DIR, "schedules.json");
+function readRaw() {
+  try {
+    if (!fs14.existsSync(REGISTRY_FILE)) return { schedules: [] };
+    const raw = fs14.readFileSync(REGISTRY_FILE, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || !Array.isArray(parsed.schedules)) return { schedules: [] };
+    return parsed;
+  } catch {
+    return { schedules: [] };
+  }
+}
+function writeRaw(file) {
+  fs14.mkdirSync(REGISTRY_DIR, { recursive: true });
+  const tmp = REGISTRY_FILE + ".tmp";
+  fs14.writeFileSync(tmp, JSON.stringify(file, null, 2));
+  fs14.renameSync(tmp, REGISTRY_FILE);
+}
+function makeScheduleId(platform, cwd) {
+  const slug = path14.basename(cwd).replace(/[^a-zA-Z0-9_-]/g, "-").toLowerCase();
+  return `${platform}-${slug}`;
+}
+function listRegistered() {
+  return readRaw().schedules;
+}
+function getRegistered(id) {
+  return readRaw().schedules.find((s) => s.id === id);
+}
+function findByPlatform(platform, cwd) {
+  const all = readRaw().schedules;
+  return all.filter((s) => s.platform === platform && (cwd ? s.cwd === cwd : true));
+}
+function upsertRegistered(entry) {
+  const file = readRaw();
+  const idx = file.schedules.findIndex((s) => s.id === entry.id);
+  if (idx >= 0) {
+    file.schedules[idx] = entry;
+  } else {
+    file.schedules.push(entry);
+  }
+  writeRaw(file);
+}
+function removeRegistered(id) {
+  const file = readRaw();
+  const before = file.schedules.length;
+  file.schedules = file.schedules.filter((s) => s.id !== id);
+  if (file.schedules.length === before) return false;
+  writeRaw(file);
+  return true;
+}
+
+// src/lib/sync/schedule.ts
+var MARKER = "# one-sync";
+var LOG_DIR_REL = path15.join(".one", "sync", "logs");
+function durationToCron(every) {
+  const match = every.match(/^(\d+)([mhd])$/);
+  if (!match) return null;
+  const amount = parseInt(match[1], 10);
+  const unit = match[2];
+  if (unit === "m") {
+    if (amount < 1 || amount > 59 || 60 % amount !== 0) return null;
+    return `*/${amount} * * * *`;
+  }
+  if (unit === "h") {
+    if (amount < 1 || amount > 23 || 24 % amount !== 0) return null;
+    return `0 */${amount} * * *`;
+  }
+  if (unit === "d") {
+    if (amount !== 1) return null;
+    return "0 0 * * *";
+  }
+  return null;
+}
+function cronExprToDuration(expr) {
+  const parts = expr.trim().split(/\s+/);
+  if (parts.length !== 5) return null;
+  const [min, hour, dom, mon, dow] = parts;
+  if (dom !== "*" || mon !== "*" || dow !== "*") return null;
+  const mm = min.match(/^\*\/(\d+)$/);
+  if (mm && hour === "*") return `${mm[1]}m`;
+  const hm = hour.match(/^\*\/(\d+)$/);
+  if (hm && min === "0") return `${hm[1]}h`;
+  if (min === "0" && hour === "0") return "1d";
+  return null;
+}
+function isWindows() {
+  return os7.platform() === "win32";
+}
+function resolveOneBinary() {
+  try {
+    const entry = process.argv[1];
+    if (entry && fs15.existsSync(entry)) {
+      return fs15.realpathSync(entry);
+    }
+  } catch {
+  }
+  return "one";
+}
+function readCrontab() {
+  try {
+    const result = spawnSync2("crontab", ["-l"], { encoding: "utf-8" });
+    if (result.status !== 0) return "";
+    return result.stdout || "";
+  } catch {
+    return "";
+  }
+}
+function writeCrontab(content) {
+  const result = spawnSync2("crontab", ["-"], { input: content, encoding: "utf-8" });
+  if (result.status !== 0) {
+    const stderr = result.stderr || "";
+    if (stderr.includes("Operation not permitted")) {
+      throw new Error(
+        "crontab write was blocked by macOS privacy protection. Grant Full Disk Access to your terminal app in System Settings \u2192 Privacy & Security \u2192 Full Disk Access, then retry."
+      );
+    }
+    throw new Error(`Failed to write crontab: ${stderr || "unknown error"}`);
+  }
+}
+function buildCronLine(entry) {
+  const modelsArg = entry.models && entry.models.length > 0 ? ` --models ${entry.models.join(",")}` : "";
+  const command = `cd ${JSON.stringify(entry.cwd)} && ${JSON.stringify(entry.nodeBin)} ${JSON.stringify(entry.cliBin)} sync run ${entry.platform}${modelsArg} >> ${JSON.stringify(entry.logFile)} 2>&1`;
+  return `${entry.cronExpr} ${command} ${MARKER}:${entry.id}`;
+}
+function crontabHasId(crontab, id, legacyPlatform) {
+  const lines = crontab.split("\n");
+  return lines.some(
+    (l) => l.includes(`${MARKER}:${id}`) || (legacyPlatform ? l.includes(`${MARKER}:${legacyPlatform}`) : false)
+  );
+}
+function removeCronLines(crontab, id, legacyPlatform) {
+  const lines = crontab.split("\n");
+  const filtered = lines.filter(
+    (l) => !l.includes(`${MARKER}:${id}`) && !(legacyPlatform && l.includes(`${MARKER}:${legacyPlatform}`) && l.includes(process.cwd()))
+  );
+  return filtered.filter((l) => l.length > 0).join("\n") + "\n";
+}
+function migrateLegacyCronEntries() {
+  const crontab = readCrontab();
+  if (!crontab.includes(MARKER)) return;
+  const registered = listRegistered();
+  const registeredIds = new Set(registered.map((s) => s.id));
+  for (const line of crontab.split("\n")) {
+    if (!line.includes(MARKER)) continue;
+    const tagMatch = line.match(new RegExp(`${MARKER}:(\\S+)\\s*$`));
+    if (!tagMatch) continue;
+    const tag = tagMatch[1];
+    if (registeredIds.has(tag)) continue;
+    const parseMatch = line.match(/^(\S+\s+\S+\s+\S+\s+\S+\s+\S+)\s+(.+?)\s+#/);
+    if (!parseMatch) continue;
+    const cronExpr = parseMatch[1];
+    const command = parseMatch[2];
+    const cwdMatch = command.match(/^cd\s+"([^"]+)"/);
+    const cwd = cwdMatch ? cwdMatch[1] : process.cwd();
+    const twoPath = command.match(/"([^"]+)"\s+"([^"]+)"\s+sync\s+run\s+(\S+)/);
+    const onePath = command.match(/&&\s+"([^"]+)"\s+sync\s+run\s+(\S+)/);
+    let nodeBin = process.execPath;
+    let cliBin = resolveOneBinary();
+    let platform = tag;
+    if (twoPath) {
+      nodeBin = twoPath[1];
+      cliBin = twoPath[2];
+      platform = twoPath[3];
+    } else if (onePath) {
+      cliBin = onePath[1];
+      platform = onePath[2];
+    }
+    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] : path15.resolve(cwd, LOG_DIR_REL, `${platform}.log`);
+    const id = makeScheduleId(platform, cwd);
+    if (registeredIds.has(id)) continue;
+    upsertRegistered({
+      id,
+      platform,
+      models,
+      every: cronExprToDuration(cronExpr) ?? cronExpr,
+      cronExpr,
+      cwd,
+      nodeBin,
+      cliBin,
+      logFile,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    registeredIds.add(id);
+  }
+}
+function addSchedule(opts) {
+  if (isWindows()) {
+    throw new Error(
+      "Scheduling via `one sync schedule` is not supported on Windows yet. Use Task Scheduler manually: create a task that runs `one sync run " + opts.platform + "` on your interval."
+    );
+  }
+  const cronExpr = durationToCron(opts.every);
+  if (!cronExpr) {
+    throw new Error(
+      `Invalid --every value "${opts.every}". Supported: <n>m (must divide 60), <n>h (must divide 24), or 1d. Examples: 15m, 30m, 1h, 6h, 12h, 1d`
+    );
+  }
+  migrateLegacyCronEntries();
+  const cwd = process.cwd();
+  const id = makeScheduleId(opts.platform, cwd);
+  const replaced = getRegistered(id) !== void 0;
+  const logDir = path15.join(cwd, LOG_DIR_REL);
+  fs15.mkdirSync(logDir, { recursive: true });
+  const logFile = path15.join(logDir, `${opts.platform}.log`);
+  const entry = {
+    id,
+    platform: opts.platform,
+    models: opts.models,
+    every: opts.every,
+    cronExpr,
+    cwd,
+    nodeBin: process.execPath,
+    cliBin: resolveOneBinary(),
+    logFile,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const current = readCrontab();
+  const cleaned = removeCronLines(current, id, opts.platform);
+  const nextLine = buildCronLine(entry);
+  const next = (cleaned.trimEnd() + "\n" + nextLine + "\n").replace(/^\n+/, "");
+  writeCrontab(next);
+  upsertRegistered(entry);
+  return { entry, replaced };
+}
+function listSchedules() {
+  migrateLegacyCronEntries();
+  const registered = listRegistered();
+  const crontab = readCrontab();
+  return registered.map((entry) => ({
+    ...entry,
+    cronInstalled: crontabHasId(crontab, entry.id, entry.platform)
+  }));
+}
+function removeSchedule(idOrPlatform, options) {
+  migrateLegacyCronEntries();
+  const byId = getRegistered(idOrPlatform);
+  let toRemove;
+  if (byId) {
+    toRemove = [byId];
+  } else {
+    const cwd = options?.allProjects ? void 0 : process.cwd();
+    toRemove = findByPlatform(idOrPlatform, cwd);
+  }
+  if (toRemove.length === 0) {
+    return { removed: [], notFound: true };
+  }
+  let crontab = readCrontab();
+  for (const entry of toRemove) {
+    crontab = removeCronLines(crontab, entry.id, entry.platform);
+    removeRegistered(entry.id);
+  }
+  writeCrontab(crontab);
+  return { removed: toRemove, notFound: false };
+}
+function scheduleStatus() {
+  const entries = listSchedules();
+  return entries.map((entry) => {
+    const logExists = fs15.existsSync(entry.logFile);
+    const logSize = logExists ? fs15.statSync(entry.logFile).size : 0;
+    let logTail = [];
+    let lastRunAt = null;
+    if (logExists) {
+      try {
+        lastRunAt = fs15.statSync(entry.logFile).mtime.toISOString();
+        if (logSize > 0) {
+          const content = fs15.readFileSync(entry.logFile, "utf-8");
+          logTail = content.trim().split("\n").slice(-10);
+        }
+      } catch {
+      }
+    }
+    let drift = "ok";
+    if (!entry.cronInstalled) drift = "missing-cron";
+    else if (!fs15.existsSync(entry.nodeBin)) drift = "stale-node-bin";
+    else if (!fs15.existsSync(entry.cliBin)) drift = "stale-cli-bin";
+    return { entry, logExists, logSize, logTail, lastRunAt, drift };
+  });
+}
+function repairSchedule(id) {
+  const entry = getRegistered(id);
+  if (!entry) throw new Error(`No registered schedule with id "${id}".`);
+  const healed = {
+    ...entry,
+    nodeBin: process.execPath,
+    cliBin: resolveOneBinary()
+  };
+  const crontab = readCrontab();
+  const cleaned = removeCronLines(crontab, healed.id, healed.platform);
+  const next = (cleaned.trimEnd() + "\n" + buildCronLine(healed) + "\n").replace(/^\n+/, "");
+  writeCrontab(next);
+  upsertRegistered(healed);
+  return healed;
+}
+
+// src/lib/sync/where-parser.ts
+function unquote(value) {
+  if (value.length >= 2) {
+    const first = value[0];
+    const last = value[value.length - 1];
+    if (first === "'" && last === "'" || first === '"' && last === '"') {
+      return value.slice(1, -1);
+    }
+  }
+  return value;
+}
+function splitConditions(input) {
+  const parts = [];
+  let buf = "";
+  let inSingle = false;
+  let inDouble = false;
+  for (let i = 0; i < input.length; i++) {
+    const ch = input[i];
+    if (ch === "'" && !inDouble) inSingle = !inSingle;
+    else if (ch === '"' && !inSingle) inDouble = !inDouble;
+    if (ch === "," && !inSingle && !inDouble) {
+      if (buf.trim().length > 0) parts.push(buf.trim());
+      buf = "";
+    } else {
+      buf += ch;
+    }
+  }
+  if (buf.trim().length > 0) parts.push(buf.trim());
+  return parts;
+}
+function parseCondition(condition) {
+  const operators = [">=", "<=", "!=", ">", "<", "=", " like "];
+  for (const op of operators) {
+    const idx = condition.toLowerCase().indexOf(op.toLowerCase());
+    if (idx > 0) {
+      const field = condition.slice(0, idx).trim();
+      const rawValue = condition.slice(idx + op.length).trim();
+      const value = unquote(rawValue);
+      const sqlOp = op.trim().toUpperCase() === "LIKE" ? "LIKE" : op.trim();
+      return { field, operator: sqlOp, value };
+    }
+  }
+  throw new Error(
+    `Cannot parse where condition: "${condition}". Expected format: field=value, field>value, field like %pattern`
+  );
+}
+
+// src/lib/sync/query.ts
+var COMMON_DATE_COLUMNS = ["created_at", "createdAt", "created", "date", "timestamp", "updated_at", "updatedAt"];
+function detectDateColumn(columns) {
+  const matches = columns.filter((c) => COMMON_DATE_COLUMNS.includes(c));
+  if (matches.length === 1) return matches[0];
+  if (matches.length > 1) return null;
+  return null;
+}
+function formatSyncAge(lastSync) {
+  const diffMs = Date.now() - new Date(lastSync).getTime();
+  const seconds = Math.floor(diffMs / 1e3);
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}m`;
+  const hours = Math.floor(minutes / 60);
+  const remainingMinutes = minutes % 60;
+  if (hours < 24) return `${hours}h ${remainingMinutes}m`;
+  const days = Math.floor(hours / 24);
+  return `${days}d ${hours % 24}h`;
+}
+async function executeQuery(platform, model, options) {
+  const db = await openDatabase(platform);
+  try {
+    if (!tableExists(db, model)) {
+      throw new Error(`No synced data for ${platform}/${model}. Run 'one sync run ${platform} --models ${model}' first.`);
+    }
+    const columns = getTableColumns(db, model).map((c) => c.name);
+    const whereClauses = [];
+    const params = [];
+    if (options.where) {
+      const conditions = splitConditions(options.where);
+      for (const cond of conditions) {
+        const parsed2 = parseCondition(cond);
+        if (!columns.includes(parsed2.field)) {
+          throw new Error(`Column "${parsed2.field}" not found. Available: ${columns.join(", ")}`);
+        }
+        whereClauses.push(`"${parsed2.field}" ${parsed2.operator} ?`);
+        params.push(parsed2.value);
+      }
+    }
+    if (options.after || options.before) {
+      let dateCol = options.dateField;
+      if (!dateCol) {
+        dateCol = detectDateColumn(columns) ?? void 0;
+        if (!dateCol) {
+          throw new Error(
+            `Cannot auto-detect date column. Use --date-field to specify. Available columns: ${columns.join(", ")}`
+          );
+        }
+      }
+      if (!columns.includes(dateCol)) {
+        throw new Error(`Date column "${dateCol}" not found. Available: ${columns.join(", ")}`);
+      }
+      if (options.after) {
+        whereClauses.push(`"${dateCol}" >= ?`);
+        params.push(options.after);
+      }
+      if (options.before) {
+        whereClauses.push(`"${dateCol}" <= ?`);
+        params.push(options.before);
+      }
+    }
+    const table = sanitizeTableName(model);
+    let sql = `SELECT * FROM "${table}"`;
+    if (whereClauses.length > 0) {
+      sql += ` WHERE ${whereClauses.join(" AND ")}`;
+    }
+    if (options.orderBy) {
+      if (!columns.includes(options.orderBy)) {
+        throw new Error(`Order column "${options.orderBy}" not found. Available: ${columns.join(", ")}`);
+      }
+      const dir = (options.order || "asc").toUpperCase();
+      sql += ` ORDER BY "${options.orderBy}" ${dir}`;
+    }
+    const limit = options.limit ?? 50;
+    sql += ` LIMIT ${limit}`;
+    const results = db.prepare(sql).all(...params);
+    const parsed = results.map((row) => {
+      const out = {};
+      for (const [key, value] of Object.entries(row)) {
+        if (typeof value === "string" && (value.startsWith("{") || value.startsWith("["))) {
+          try {
+            out[key] = JSON.parse(value);
+          } catch {
+            out[key] = value;
+          }
+        } else {
+          out[key] = value;
+        }
+      }
+      return out;
+    });
+    const state = getModelState(platform, model);
+    const lastSync = state?.lastSync ?? null;
+    const syncAge = lastSync ? formatSyncAge(lastSync) : null;
+    db.close();
+    return {
+      platform,
+      model,
+      results: parsed,
+      total: parsed.length,
+      query: sql,
+      source: "local",
+      lastSync,
+      syncAge
+    };
+  } catch (err) {
+    db.close();
+    throw err;
+  }
+}
+async function executeRawSql(platform, sql) {
+  const trimmed = sql.trim();
+  const upper = trimmed.toUpperCase();
+  if (!upper.startsWith("SELECT")) {
+    throw new Error("Only SELECT statements are allowed. Sync databases are read-only.");
+  }
+  const forbidden = /\b(PRAGMA|ATTACH|DETACH|INSERT|UPDATE|DELETE|DROP|ALTER|CREATE|REPLACE|VACUUM)\b/;
+  if (forbidden.test(upper)) {
+    throw new Error("Only pure SELECT queries are allowed. PRAGMA/ATTACH/DDL/DML are blocked.");
+  }
+  const db = await openDatabase(platform);
+  try {
+    const results = db.prepare(trimmed).all();
+    const parsed = results.map((row) => {
+      const out = {};
+      for (const [key, value] of Object.entries(row)) {
+        if (typeof value === "string" && (value.startsWith("{") || value.startsWith("["))) {
+          try {
+            out[key] = JSON.parse(value);
+          } catch {
+            out[key] = value;
+          }
+        } else {
+          out[key] = value;
+        }
+      }
+      return out;
+    });
+    db.close();
+    return { results: parsed, query: trimmed };
+  } catch (err) {
+    db.close();
+    throw err;
+  }
+}
+
+// src/lib/sync/search.ts
+async function searchSyncedData(query, options) {
+  const limit = options.limit ?? 20;
+  const platforms = options.platform ? [options.platform] : listSyncedPlatforms();
+  if (platforms.length === 0) {
+    throw new Error("No synced data found. Run 'one sync run <platform>' first.");
+  }
+  const ftsQuery = query.split(/\s+/).map((term) => term.includes("*") || term.includes('"') ? term : `${term}*`).join(" ");
+  const allResults = [];
+  for (const platform of platforms) {
+    const db = await openDatabase(platform);
+    try {
+      const tables = options.models ?? listTables(db);
+      for (const model of tables) {
+        if (!tableExists(db, model)) continue;
+        const ftsTable = `${model}_fts`;
+        const ftsExists = db.prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name=?`).get(ftsTable);
+        if (!ftsExists) continue;
+        try {
+          const rows = db.prepare(`
+            SELECT "${model}".*, "${ftsTable}".rank
+            FROM "${ftsTable}"
+            JOIN "${model}" ON "${model}".rowid = "${ftsTable}".rowid
+            WHERE "${ftsTable}" MATCH ?
+            ORDER BY rank
+            LIMIT ?
+          `).all(ftsQuery, limit);
+          for (const row of rows) {
+            const rank = row.rank;
+            const record = {};
+            for (const [key, value] of Object.entries(row)) {
+              if (key === "rank") continue;
+              if (typeof value === "string" && (value.startsWith("{") || value.startsWith("["))) {
+                try {
+                  record[key] = JSON.parse(value);
+                } catch {
+                  record[key] = value;
+                }
+              } else {
+                record[key] = value;
+              }
+            }
+            allResults.push({ platform, model, record, rank });
+          }
+        } catch {
+        }
+      }
+      db.close();
+    } catch {
+      try {
+        db.close();
+      } catch {
+      }
+    }
+  }
+  allResults.sort((a, b) => a.rank - b.rank);
+  const limited = allResults.slice(0, limit);
+  return {
+    results: limited,
+    total: limited.length
+  };
+}
+
+// src/lib/sync/index.ts
+import { spawn as spawn4 } from "child_process";
+import * as p7 from "@clack/prompts";
+import pc9 from "picocolors";
+async function syncInstallCommand() {
+  if (await isSqliteAvailable()) {
+    if (isAgentMode()) {
+      json({ status: "already-installed", module: "better-sqlite3" });
+    } else {
+      note2("better-sqlite3 is already installed.", "Sync");
+    }
+    return;
+  }
+  if (!isAgentMode()) {
+    process.stderr.write("Installing better-sqlite3 (native module, may take ~30s)...\n");
+  }
+  const install = (args) => new Promise((resolve) => {
+    const child = spawn4("npm", args, { stdio: isAgentMode() ? "ignore" : "inherit" });
+    child.on("exit", (code2) => resolve(code2 ?? 1));
+    child.on("error", () => resolve(1));
+  });
+  let code = await install(["install", "-g", "better-sqlite3"]);
+  if (code !== 0) {
+    code = await install(["install", "better-sqlite3"]);
+  }
+  if (code !== 0) {
+    error(
+      "Failed to install better-sqlite3. This usually means your system is missing build tools.\nOn macOS: xcode-select --install\nOn Linux: install python3, make, g++\nThen retry: one sync install"
+    );
+  }
+  if (isAgentMode()) {
+    json({ status: "installed", module: "better-sqlite3" });
+  } else {
+    outro2("better-sqlite3 installed. You can now run one sync commands.");
+  }
+}
+async function syncDoctorCommand() {
+  const checks = [];
+  try {
+    const Database = await loadSqlite();
+    checks.push({ name: "better-sqlite3 loads", ok: true });
+    try {
+      const db = new Database(":memory:");
+      db.exec("CREATE TABLE t (x INTEGER); INSERT INTO t VALUES (1);");
+      const row = db.prepare("SELECT x FROM t").get();
+      db.close();
+      checks.push({ name: "in-memory DB read/write", ok: row.x === 1 });
+    } catch (err) {
+      checks.push({ name: "in-memory DB read/write", ok: false, detail: err instanceof Error ? err.message : String(err) });
+    }
+    try {
+      const db = new Database(":memory:");
+      db.exec("CREATE VIRTUAL TABLE t USING fts5(content)");
+      db.close();
+      checks.push({ name: "FTS5 virtual table support", ok: true });
+    } catch (err) {
+      checks.push({ name: "FTS5 virtual table support", ok: false, detail: err instanceof Error ? err.message : String(err) });
+    }
+  } catch (err) {
+    checks.push({ name: "better-sqlite3 loads", ok: false, detail: err instanceof Error ? err.message : String(err) });
+  }
+  const allOk = checks.every((c) => c.ok);
+  if (isAgentMode()) {
+    json({ ok: allOk, checks });
+    return;
+  }
+  for (const c of checks) {
+    const mark = c.ok ? pc9.green("\u2713") : pc9.red("\u2717");
+    console.log(`  ${mark} ${c.name}${c.detail ? pc9.dim(` \u2014 ${c.detail}`) : ""}`);
+  }
+  if (!allOk) {
+    console.log(`
+${pc9.yellow("Sync is not ready.")} Try: ${pc9.bold("one sync install")}`);
+  } else {
+    console.log(`
+${pc9.green("Sync is ready.")}`);
+  }
+}
+function getApi() {
+  const apiKey = getApiKey();
+  if (!apiKey) {
+    error('No API key configured. Run "one init" first.');
+  }
+  return new OneApi(apiKey);
+}
+async function syncProfilesCommand(platform) {
+  const profiles = listBuiltinProfiles(platform);
+  if (isAgentMode()) {
+    json({
+      profiles: profiles.map((p8) => ({
+        platform: p8.platform,
+        model: p8.model,
+        description: p8.description,
+        hasEnrich: !!p8.enrich,
+        hasIdentityKey: !!p8.identityKey
+      })),
+      total: profiles.length,
+      _hint: profiles.length > 0 ? "Use a built-in profile: one --agent sync init <platform> <model>" : "No built-in profiles found. Use sync init to auto-infer from action knowledge."
+    });
+    return;
+  }
+  if (profiles.length === 0) {
+    note2(
+      platform ? `No built-in profiles for ${platform}. Use sync init to auto-infer from action knowledge.` : "No built-in profiles found.",
+      "Profiles"
+    );
+    return;
+  }
+  for (const p8 of profiles) {
+    const extras = [];
+    if (p8.enrich) extras.push("enrich");
+    if (p8.identityKey) extras.push("identity");
+    if (p8.dateFilter) extras.push("incremental");
+    const tags = extras.length > 0 ? ` ${pc9.dim(`[${extras.join(", ")}]`)}` : "";
+    console.log(`  ${pc9.bold(`${p8.platform}/${p8.model}`.padEnd(35))} ${p8.description}${tags}`);
+  }
+  console.log(`
+${profiles.length} built-in profile(s). Run ${pc9.bold("one sync init <platform> <model>")} to use one.`);
+}
+async function syncModelsCommand(platform) {
+  const api = getApi();
+  const spinner5 = createSpinner();
+  spinner5.start(`Discovering models for ${platform}...`);
+  try {
+    const models = await discoverModels(api, platform);
+    spinner5.stop(`Found ${models.length} models`);
+    if (isAgentMode()) {
+      json({ platform, models, total: models.length });
+      return;
+    }
+    if (models.length === 0) {
+      note2("No list-type actions found for this platform.", "Models");
+      return;
+    }
+    const lines = models.map(
+      (m) => `  ${pc9.bold(m.name.padEnd(30))} ${pc9.dim(m.listAction.method)} ${pc9.dim(m.listAction.path)}`
+    );
+    note2(lines.join("\n"), `${platform} \u2014 ${models.length} models`);
+  } catch (err) {
+    spinner5.stop("Failed");
+    error(`Error discovering models: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+async function syncInitCommand(platform, model, options) {
+  if (!options.config) {
+    const api = getApi();
+    const spinner5 = createSpinner();
+    spinner5.start(`Looking up ${platform}/${model}...`);
+    try {
+      const models = await discoverModels(api, platform);
+      const match = models.find((m) => m.name === model || m.name.toLowerCase() === model.toLowerCase());
+      let actionId;
+      if (match) {
+        actionId = match.listAction.actionId;
+        if (actionId && !actionId.startsWith("conn_mod_def::")) {
+          actionId = void 0;
+        }
+        spinner5.stop(actionId ? "Found model + action ID" : "Found model (action ID not resolved)");
+      } else {
+        spinner5.stop("Model not found in available actions");
+      }
+      const builtin = loadBuiltinProfile(platform, model);
+      let template;
+      let inferred = null;
+      if (builtin) {
+        template = { ...builtin };
+        if (actionId) template.actionId = actionId;
+        delete template.description;
+        inferred = { reasoning: [`Built-in profile found for ${platform}/${model}: "${builtin.description}"`] };
+      } else {
+        template = generateTemplate(platform, model, actionId);
+      }
+      if (actionId && !builtin) {
+        try {
+          const knowledgeResp = await api.getActionKnowledge(actionId);
+          inferred = inferProfileFromKnowledge(knowledgeResp?.knowledge, model, platform);
+          if (inferred.pagination) template.pagination = inferred.pagination;
+          if (inferred.resultsPath) template.resultsPath = inferred.resultsPath;
+          if (inferred.idField) template.idField = inferred.idField;
+          if (inferred.dateFilterParam) {
+            template.dateFilter = { param: inferred.dateFilterParam, format: "iso8601" };
+          }
+          if (inferred.limitLocation) template.limitLocation = inferred.limitLocation;
+          if (inferred.limitParam) template.limitParam = inferred.limitParam;
+          if (inferred.pathVars && Object.keys(inferred.pathVars).length > 0) {
+            template.pathVars = inferred.pathVars;
+          }
+        } catch {
+        }
+      }
+      try {
+        const connections = await api.listConnections();
+        const platformConns = connections.filter(
+          (c) => c.platform === platform
+        );
+        if (platformConns.length === 1) {
+          template.connectionKey = platformConns[0].key;
+          inferred?.reasoning.push(`connectionKey: auto-resolved (only one ${platform} connection)`);
+        } else if (platformConns.length > 1) {
+          inferred?.reasoning.push(
+            `connectionKey: ${platformConns.length} connections found \u2014 pick one from \`one list\``
+          );
+        }
+      } catch {
+      }
+      try {
+        writeDraftProfile(platform, model, template);
+      } catch {
+      }
+      const templateStr = JSON.stringify(template);
+      const isComplete = !templateStr.includes("FILL_IN");
+      let testReport = null;
+      if (isComplete) {
+        try {
+          testReport = await testSyncProfile(api, template);
+          if (testReport.autoFixed && Object.keys(testReport.autoFixed).length > 0) {
+            Object.assign(template, testReport.autoFixed);
+            try {
+              writeDraftProfile(platform, model, template);
+            } catch {
+            }
+          }
+        } catch {
+        }
+      }
+      const hint = isComplete ? testReport?.ok ? `Profile complete and validated. Run: one sync run ${platform} --models ${model}` : `Profile complete but test had issues \u2014 check the test report below.` : actionId ? `Fill remaining FILL_IN fields, then: one sync test ${platform}/${model}` : `Action ID not resolved. Run: one --agent actions search ${platform} "list ${model}" -t execute`;
+      if (isAgentMode()) {
+        json({
+          ...template,
+          _hint: hint,
+          _inferred: inferred?.reasoning ?? [],
+          _draft: !isComplete,
+          _complete: isComplete,
+          ...testReport ? { _test: { ok: testReport.ok, checks: testReport.checks, autoFixed: testReport.autoFixed } } : {}
+        });
+      } else {
+        note2(JSON.stringify(template, null, 2), "Sync profile template");
+        if (inferred && inferred.reasoning.length > 0) {
+          console.log(`
+${pc9.bold("Inferred from knowledge:")}`);
+          for (const r of inferred.reasoning) console.log(`  ${pc9.dim("\u2022")} ${r}`);
+        }
+        if (testReport) {
+          console.log(`
+${pc9.bold("Test results:")}`);
+          for (const c of testReport.checks) {
+            const mark = c.ok ? pc9.green("\u2713") : pc9.red("\u2717");
+            console.log(`  ${mark} ${c.name}${c.detail ? pc9.dim(` \u2014 ${c.detail}`) : ""}`);
+          }
+        }
+        console.log(`
+${hint}`);
+        if (!isComplete) {
+          console.log(`
+Run with --config to save:
+  one sync init ${platform} ${model} --config '${JSON.stringify(template)}'`);
+        }
+      }
+    } catch (err) {
+      spinner5.stop("Failed");
+      error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    return;
+  }
+  let patch;
+  try {
+    patch = JSON.parse(options.config);
+  } catch {
+    error("Invalid JSON in --config. Provide a valid JSON sync profile.");
+    return;
+  }
+  const existing = readProfile(platform, model);
+  const profile = {
+    ...existing ?? {},
+    ...patch,
+    // Ensure platform/model from args always win
+    platform,
+    model,
+    // Deep-merge pagination so you can patch just nextPath without losing type
+    pagination: {
+      ...existing?.pagination ?? {},
+      ...patch.pagination ?? {}
+    }
+  };
+  try {
+    writeProfile(profile);
+    if (isAgentMode()) {
+      json({ status: "created", platform, model, profile });
+    } else {
+      outro2(`Sync profile saved for ${platform}/${model}`);
+    }
+  } catch (err) {
+    error(`Error saving profile: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+async function syncTestCommand(platformModel) {
+  const [platform, model] = platformModel.split("/");
+  if (!platform || !model) {
+    error("Usage: one sync test <platform>/<model>. Example: one sync test shopify/orders");
+  }
+  const profile = readProfile(platform, model);
+  if (!profile) {
+    error(
+      `No sync profile found for ${platform}/${model}. Create one with: one sync init ${platform} ${model} --config '...'`
+    );
+  }
+  const api = getApi();
+  const report = await testSyncProfile(api, profile);
+  if (report.autoFixed && Object.keys(report.autoFixed).length > 0) {
+    try {
+      const existing = readProfile(platform, model);
+      if (existing) {
+        const patched = { ...existing, ...report.autoFixed };
+        writeProfile(patched);
+      }
+    } catch {
+    }
+  }
+  if (isAgentMode()) {
+    json(report);
+    return;
+  }
+  for (const c of report.checks) {
+    const mark = c.ok ? pc9.green("\u2713") : pc9.red("\u2717");
+    console.log(`  ${mark} ${c.name}${c.detail ? pc9.dim(` \u2014 ${c.detail}`) : ""}`);
+  }
+  if (report.detectedColumns && report.detectedColumns.length > 0) {
+    console.log(`
+  ${pc9.bold("Detected columns:")}`);
+    for (const col of report.detectedColumns.slice(0, 20)) {
+      console.log(`    ${col.name.padEnd(30)} ${pc9.dim(col.type)}`);
+    }
+    if (report.detectedColumns.length > 20) {
+      console.log(pc9.dim(`    ... and ${report.detectedColumns.length - 20} more`));
+    }
+  }
+  console.log(
+    `
+${report.ok ? pc9.green("Profile looks good.") : pc9.red("Profile has issues.")} ` + (report.ok ? `Run: ${pc9.bold(`one sync run ${platform} --models ${model}`)}` : "Fix the issues above and test again.")
+  );
+}
+async function syncRunCommand(platform, options) {
+  const api = getApi();
+  const profiles = listProfiles(platform);
+  const targetModels = options.models;
+  const toSync = targetModels ? profiles.filter((p8) => targetModels.includes(p8.model)) : profiles;
+  if (toSync.length === 0) {
+    error(
+      `No sync profiles found for ${platform}` + (targetModels ? ` with models: ${targetModels.join(", ")}` : "") + `. Run 'one sync init ${platform} <model> --config ...' first.`
+    );
+  }
+  const results = [];
+  for (const profile of toSync) {
+    try {
+      const result = await syncModel(api, profile, options);
+      results.push(result);
+    } catch (err) {
+      const errObj = err;
+      results.push({
+        model: profile.model,
+        recordsSynced: errObj?._recordsSynced ?? 0,
+        pagesProcessed: errObj?._pagesProcessed ?? 0,
+        duration: "0s",
+        status: "failed",
+        error: err instanceof Error ? err.message : String(err)
+      });
+    }
+  }
+  if (isAgentMode()) {
+    json({ platform, results });
+    return;
+  }
+  for (const r of results) {
+    const status = r.status === "complete" ? pc9.green("complete") : r.status === "dry-run" ? pc9.yellow("dry-run") : pc9.red("failed");
+    console.log(`  ${pc9.bold(r.model)} \u2014 ${r.recordsSynced} records, ${r.pagesProcessed} pages, ${r.duration} [${status}]`);
+    if ("error" in r && r.error) {
+      console.log(`    ${pc9.red(r.error)}`);
+    }
+  }
+}
+async function syncQueryCommand(platformModel, options) {
+  const [platform, model] = platformModel.split("/");
+  if (!platform || !model) {
+    error("Usage: one sync query <platform>/<model>. Example: one sync query shopify/orders");
+  }
+  if (options.refresh) {
+    const api = getApi();
+    const profile = readProfile(platform, model);
+    if (profile) {
+      if (!isAgentMode()) {
+        process.stderr.write(`Refreshing ${platform}/${model}...
+`);
+      }
+      await syncModel(api, profile, { force: options.refreshForce });
+    }
+  }
+  try {
+    const result = await executeQuery(platform, model, options);
+    if (isAgentMode()) {
+      json(result);
+      return;
+    }
+    console.log(pc9.dim(`Query: ${result.query}`));
+    console.log(pc9.dim(`Source: local | Last sync: ${result.lastSync ?? "never"} | Age: ${result.syncAge ?? "n/a"}`));
+    console.log(JSON.stringify(result.results, null, 2));
+    console.log(`
+${result.total} results`);
+  } catch (err) {
+    error(`Query error: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+async function syncSearchCommand(query, options) {
+  const modelList = options.models?.split(",").map((m) => m.trim());
+  const limit = options.limit ? parseInt(options.limit, 10) : 20;
+  try {
+    const result = await searchSyncedData(query, { platform: options.platform, models: modelList, limit });
+    if (isAgentMode()) {
+      json(result);
+      return;
+    }
+    if (result.results.length === 0) {
+      note2("No results found.", "Search");
+      return;
+    }
+    for (const r of result.results) {
+      console.log(`  ${pc9.bold(`${r.platform}/${r.model}`)} ${pc9.dim(`(rank: ${r.rank.toFixed(2)})`)}`);
+      console.log(`    ${JSON.stringify(r.record)}`);
+    }
+    console.log(`
+${result.total} results`);
+  } catch (err) {
+    error(`Search error: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+async function syncSqlCommand(platform, sql) {
+  try {
+    const result = await executeRawSql(platform, sql);
+    if (isAgentMode()) {
+      json({ platform, ...result, total: result.results.length });
+      return;
+    }
+    console.log(JSON.stringify(result.results, null, 2));
+    console.log(`
+${result.results.length} rows`);
+  } catch (err) {
+    error(`SQL error: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+async function syncDeleteCommand(platformModel, options) {
+  const [platform, model] = platformModel.split("/");
+  if (!platform || !model) {
+    error('Usage: one sync delete <platform>/<model> --id <id> or --where "field=value"');
+  }
+  if (!options.id && !options.where && !options.whereSql) {
+    error('Provide --id <value>, --where "field=value", or --where-sql "SQL predicate" to specify which records to delete.');
+  }
+  const db = await openDatabase(platform);
+  try {
+    if (!tableExists(db, model)) {
+      db.close();
+      error(`No synced data for ${platform}/${model}.`);
+    }
+    let where;
+    let params;
+    if (options.id) {
+      const profile = readProfile(platform, model);
+      const idField = profile?.idField || "id";
+      where = `"${idField}" = ?`;
+      params = [options.id];
+    } else if (options.whereSql) {
+      where = options.whereSql;
+      params = [];
+    } else {
+      const conditions = splitConditions(options.where);
+      const clauses = [];
+      params = [];
+      for (const cond of conditions) {
+        try {
+          const parsed = parseCondition(cond);
+          clauses.push(`"${parsed.field}" ${parsed.operator} ?`);
+          params.push(parsed.value);
+        } catch (err) {
+          db.close();
+          error(err instanceof Error ? err.message : String(err));
+        }
+      }
+      where = clauses.join(" AND ");
+    }
+    const safeTable = sanitizeTableName(model);
+    const preview = db.prepare(`SELECT COUNT(*) as count FROM "${safeTable}" WHERE ${where}`).get(...params);
+    if (preview.count === 0) {
+      db.close();
+      if (isAgentMode()) {
+        json({ deleted: 0, platform, model });
+      } else {
+        console.log("No matching records found.");
+      }
+      return;
+    }
+    if (!options.yes && !isAgentMode()) {
+      const confirmed = await p7.confirm({ message: `Delete ${preview.count} record(s) from ${platform}/${model}?` });
+      if (p7.isCancel(confirmed) || !confirmed) {
+        db.close();
+        cancel2("Cancelled.");
+        return;
+      }
+    }
+    const deleted = deleteRecords(db, model, where, params);
+    rebuildFtsIndex(db, model);
+    db.close();
+    if (isAgentMode()) {
+      json({ deleted, platform, model });
+    } else {
+      console.log(`Deleted ${deleted} record(s) from ${platform}/${model}.`);
+    }
+  } catch (err) {
+    db.close();
+    error(`Delete error: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+async function syncListCommand(platform) {
+  const profiles = listProfiles(platform);
+  const state = readSyncState();
+  const syncs = profiles.map((p8) => {
+    const modelState = state[p8.platform]?.[p8.model];
+    return {
+      platform: p8.platform,
+      model: p8.model,
+      lastSync: modelState?.lastSync ?? null,
+      totalRecords: modelState?.totalRecords ?? 0,
+      pagesProcessed: modelState?.pagesProcessed ?? 0,
+      dbSize: getDatabaseSize(p8.platform),
+      status: modelState?.status ?? "idle"
+    };
+  });
+  if (isAgentMode()) {
+    json({ syncs });
+    return;
+  }
+  if (syncs.length === 0) {
+    note2("No sync profiles configured.", "Sync");
+    return;
+  }
+  for (const s of syncs) {
+    const status = s.status === "idle" ? pc9.green("idle") : s.status === "syncing" ? pc9.yellow(`syncing \u2014 page ${s.pagesProcessed}`) : pc9.red("failed");
+    console.log(
+      `  ${pc9.bold(`${s.platform}/${s.model}`.padEnd(35))} ${String(s.totalRecords).padStart(8)} records  ${s.dbSize.padStart(10)}  ${status}  ${pc9.dim(s.lastSync ? `last: ${s.lastSync}` : "never synced")}`
+    );
+  }
+}
+async function syncRemoveCommand(platform, options) {
+  const modelList = options.models?.split(",").map((m) => m.trim());
+  const preview = [];
+  const profiles = listProfiles(platform);
+  const targetModels = modelList ?? profiles.map((p8) => p8.model);
+  try {
+    if (targetModels.length > 0) {
+      const db = await openDatabase(platform);
+      for (const model of targetModels) {
+        preview.push({ model, records: tableExists(db, model) ? countRecords(db, model) : 0 });
+      }
+      db.close();
+    }
+  } catch {
+    for (const model of targetModels) preview.push({ model, records: 0 });
+  }
+  const totalRecords = preview.reduce((sum, p8) => sum + p8.records, 0);
+  const dbSize = getDatabaseSize(platform);
+  if (options.dryRun) {
+    if (isAgentMode()) {
+      json({ dryRun: true, platform, models: preview, totalRecords, dbSize });
+    } else {
+      note2(
+        preview.map((p8) => `  ${p8.model.padEnd(30)} ${String(p8.records).padStart(8)} records`).join("\n") + `
+
+  Total: ${totalRecords} records across ${preview.length} model(s), ${dbSize} on disk`,
+        `Would remove from ${platform}`
+      );
+    }
+    return;
+  }
+  if (!options.yes && !isAgentMode()) {
+    const target = modelList ? `${platform}/${modelList.join(", ")}` : `all synced data for ${platform}`;
+    const confirmed = await p7.confirm({
+      message: `Remove ${target}? (${totalRecords} records, ${dbSize} on disk)`
+    });
+    if (p7.isCancel(confirmed) || !confirmed) {
+      cancel2("Cancelled.");
+      return;
+    }
+  }
+  try {
+    if (modelList) {
+      const db = await openDatabase(platform);
+      for (const model of modelList) {
+        dropTable(db, model);
+        removeModelState(platform, model);
+      }
+      db.close();
+    } else {
+      deleteDatabase(platform);
+      removeModelState(platform);
+    }
+    if (isAgentMode()) {
+      json({ status: "removed", platform, models: modelList ?? "all" });
+    } else {
+      outro2(`Removed sync data for ${platform}${modelList ? `/${modelList.join(", ")}` : ""}`);
+    }
+  } catch (err) {
+    error(`Error: ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+async function syncScheduleAddCommand(platform, options) {
+  try {
+    const { entry, replaced } = addSchedule({
+      platform,
+      every: options.every,
+      models: options.models?.split(",").map((m) => m.trim())
+    });
+    if (isAgentMode()) {
+      json({ status: replaced ? "replaced" : "scheduled", ...entry });
+      return;
+    }
+    const verb = replaced ? "Replaced existing schedule" : "Scheduled sync";
+    outro2(
+      `${verb} ${pc9.bold(entry.id)} \u2014 every ${pc9.bold(entry.every)} (cron: ${pc9.dim(entry.cronExpr)})
+Logs: ${pc9.dim(entry.logFile)}`
+    );
+  } catch (err) {
+    error(err instanceof Error ? err.message : String(err));
+  }
+}
+async function syncScheduleListCommand() {
+  try {
+    const entries = listSchedules();
+    if (isAgentMode()) {
+      json({ schedules: entries });
+      return;
+    }
+    if (entries.length === 0) {
+      note2("No scheduled syncs. Add one with: one sync schedule add <platform> --every 1h", "Schedule");
+      return;
+    }
+    for (const e of entries) {
+      const modelsStr = e.models ? ` [${e.models.join(",")}]` : "";
+      const installed = e.cronInstalled ? pc9.green("\u25CF") : pc9.red("\u2717");
+      console.log(
+        `  ${installed} ${pc9.bold(e.id.padEnd(32))} every ${pc9.bold(e.every.padEnd(5))} ${pc9.dim(e.cronExpr.padEnd(13))}${modelsStr}`
+      );
+      console.log(`      ${pc9.dim("cwd:")} ${e.cwd}`);
+    }
+    console.log(`
+${pc9.dim("\u25CF = cron line installed  \u2717 = registry drift, run `sync schedule repair <id>`")}`);
+  } catch (err) {
+    error(err instanceof Error ? err.message : String(err));
+  }
+}
+async function syncScheduleRemoveCommand(idOrPlatform, options) {
+  try {
+    const result = removeSchedule(idOrPlatform, { allProjects: options.all });
+    if (isAgentMode()) {
+      json({
+        status: result.notFound ? "not-found" : "removed",
+        idOrPlatform,
+        removed: result.removed.map((r) => ({ id: r.id, platform: r.platform, cwd: r.cwd }))
+      });
+      return;
+    }
+    if (result.notFound) {
+      note2(
+        `No scheduled sync found for "${idOrPlatform}"${options.all ? "" : " in this directory"}. Run \`one sync schedule list\` to see all schedules, or pass --all to match across projects.`,
+        "Schedule"
+      );
+      return;
+    }
+    for (const r of result.removed) {
+      console.log(`  ${pc9.green("\u2713")} removed ${pc9.bold(r.id)} ${pc9.dim(`(${r.cwd})`)}`);
+    }
+  } catch (err) {
+    error(err instanceof Error ? err.message : String(err));
+  }
+}
+async function syncScheduleStatusCommand() {
+  try {
+    const statuses = scheduleStatus();
+    if (isAgentMode()) {
+      json({ schedules: statuses });
+      return;
+    }
+    if (statuses.length === 0) {
+      note2("No scheduled syncs.", "Schedule");
+      return;
+    }
+    for (const s of statuses) {
+      const driftMarker = s.drift === "ok" ? pc9.green("\u25CF") : s.drift === "missing-cron" ? pc9.red("\u2717 missing cron line") : pc9.yellow(`\u26A0 ${s.drift}`);
+      console.log(`  ${driftMarker} ${pc9.bold(s.entry.id)} \u2014 every ${s.entry.every} (${pc9.dim(s.entry.cronExpr)})`);
+      console.log(`      ${pc9.dim("cwd:")} ${s.entry.cwd}`);
+      console.log(`      ${pc9.dim("last run:")} ${s.lastRunAt ?? pc9.yellow("never")}`);
+      console.log(`      ${pc9.dim("log:")} ${s.entry.logFile} ${s.logExists ? pc9.dim(`(${s.logSize} bytes)`) : pc9.yellow("(empty)")}`);
+      if (s.logTail.length > 0) {
+        console.log(pc9.dim("      last lines:"));
+        for (const line of s.logTail.slice(-3)) {
+          console.log(pc9.dim(`        ${line}`));
+        }
+      }
+    }
+    if (statuses.some((s) => s.drift !== "ok")) {
+      console.log(`
+${pc9.yellow("Drift detected.")} Run ${pc9.bold("one sync schedule repair <id>")} to heal.`);
+    }
+  } catch (err) {
+    error(err instanceof Error ? err.message : String(err));
+  }
+}
+async function syncScheduleRepairCommand(id) {
+  try {
+    const healed = repairSchedule(id);
+    if (isAgentMode()) {
+      json({ status: "repaired", ...healed });
+      return;
+    }
+    outro2(`Repaired ${pc9.bold(healed.id)}: re-installed cron line with current node/cli paths.`);
+  } catch (err) {
+    error(err instanceof Error ? err.message : String(err));
+  }
+}
+function registerSyncCommands(program2) {
+  const sync = program2.command("sync").alias("s").description("Sync platform data locally for instant offline queries");
+  sync.command("install").description("Install the local sync engine (better-sqlite3 native module)").action(async () => {
+    await syncInstallCommand();
+  });
+  sync.command("doctor").description("Verify the local sync engine is installed and working").action(async () => {
+    await syncDoctorCommand();
+  });
+  sync.command("profiles [platform]").description("List built-in sync profiles (pre-validated configs for common platforms)").action(async (platform) => {
+    await syncProfilesCommand(platform);
+  });
+  sync.command("models <platform>").description("Discover available data models for a platform").action(async (platform) => {
+    await syncModelsCommand(platform);
+  });
+  sync.command("init <platform> <model>").description("Create or update a sync profile for a model").option("--config <json>", "Sync profile configuration as JSON").action(async (platform, model, options) => {
+    await syncInitCommand(platform, model, options);
+  });
+  sync.command("test <platform/model>").description("Validate a sync profile with a single-page fetch (no DB writes)").action(async (platformModel) => {
+    await syncTestCommand(platformModel);
+  });
+  sync.command("run <platform>").description("Run sync for a platform (syncs all configured models, or specify --models)").option("--models <models>", "Comma-separated list of models to sync").option("--since <duration>", "Sync records since duration (e.g. 90d, 30d, 7d) or date").option("--force", "Ignore existing sync state and start fresh").option("--max-pages <n>", "Maximum number of pages to fetch").option("--dry-run", "Fetch first page only, show results without persisting").option("--full-refresh", "Fetch ALL records and delete local rows no longer in the source (handles deletions)").action(async (platform, options) => {
+    await syncRunCommand(platform, {
+      models: options.models?.split(",").map((m) => m.trim()),
+      since: options.since,
+      force: options.force,
+      maxPages: options.maxPages ? parseInt(options.maxPages, 10) : void 0,
+      dryRun: options.dryRun,
+      fullRefresh: options.fullRefresh
+    });
+  });
+  sync.command("query <platform/model>").description('Query local synced data (e.g. one sync query shopify/orders --where "status=unfulfilled")').option("--where <conditions>", 'Filter conditions (e.g. "status=active,plan=pro")').option("--after <date>", "Records after this date").option("--before <date>", "Records before this date").option("--limit <n>", "Max results (default: 50)").option("--order-by <field>", "Sort by field").option("--order <dir>", "Sort direction: asc or desc").option("--refresh", "Trigger incremental sync before querying").option("--refresh-force", "Trigger full re-sync before querying (implies --refresh)").option("--date-field <field>", "Specify date column for --after/--before").action(async (platformModel, options) => {
+    await syncQueryCommand(platformModel, {
+      where: options.where,
+      after: options.after,
+      before: options.before,
+      limit: options.limit ? parseInt(options.limit, 10) : void 0,
+      orderBy: options.orderBy,
+      order: options.order,
+      refresh: options.refresh || options.refreshForce,
+      refreshForce: options.refreshForce,
+      dateField: options.dateField
+    });
+  });
+  sync.command("search <query>").description("Full-text search across all synced data (or filter by --platform / --models)").option("--platform <platform>", "Search only this platform (default: all)").option("--models <models>", "Comma-separated list of models to search").option("--limit <n>", "Max results (default: 20)").action(async (query, options) => {
+    await syncSearchCommand(query, options);
+  });
+  sync.command("sql <platform> <sql>").description("Execute raw SQL against local sync database (SELECT only)").action(async (platform, sql) => {
+    await syncSqlCommand(platform, sql);
+  });
+  sync.command("delete <platform/model>").description('Delete records from local sync data (e.g. one sync delete notion/pages --id "abc-123")').option("--id <value>", "Delete record by ID").option("--where <conditions>", 'Delete records matching conditions (e.g. "status=archived")').option("--where-sql <predicate>", `Delete using a raw SQL WHERE clause (e.g. "json_extract(data, '$.type') = 'promotion'")`).option("--yes", "Skip confirmation prompt").action(async (platformModel, options) => {
+    await syncDeleteCommand(platformModel, options);
+  });
+  sync.command("list [platform]").alias("ls").description("List all configured sync profiles and their status").action(async (platform) => {
+    await syncListCommand(platform);
+  });
+  const schedule = sync.command("schedule").description("Manage scheduled syncs (runs via system cron on macOS/Linux)");
+  schedule.command("add <platform>").description("Schedule a sync to run on an interval (e.g. --every 1h)").requiredOption("--every <duration>", "Interval: <n>m (divides 60), <n>h (divides 24), or 1d").option("--models <models>", "Only sync these models (comma-separated)").action(async (platform, options) => {
+    await syncScheduleAddCommand(platform, options);
+  });
+  schedule.command("list").alias("ls").description("List all scheduled syncs").action(async () => {
+    await syncScheduleListCommand();
+  });
+  schedule.command("remove <id-or-platform>").alias("rm").description("Remove a scheduled sync by id, or by platform (defaults to current directory)").option("--all", "When matching by platform, remove across all projects").action(async (idOrPlatform, options) => {
+    await syncScheduleRemoveCommand(idOrPlatform, options);
+  });
+  schedule.command("status").description("Show scheduled syncs with last-run time, log tail, and drift detection").action(async () => {
+    await syncScheduleStatusCommand();
+  });
+  schedule.command("repair <id>").description("Re-install a schedule whose cron line is missing or broken (drift)").action(async (id) => {
+    await syncScheduleRepairCommand(id);
+  });
+  sync.command("remove <platform>").description("Remove sync data and profiles for a platform").option("--models <models>", "Specific models to remove (comma-separated)").option("--dry-run", "Show what would be removed without deleting").option("--yes", "Skip confirmation prompt").action(async (platform, options) => {
+    await syncRemoveCommand(platform, options);
+  });
+}
+
+// src/commands/cache.ts
+import pc10 from "picocolors";
+async function cacheClearCommand(actionId) {
+  if (actionId) {
+    const deleted = clearEntry(actionId);
+    if (isAgentMode()) {
+      json({ cleared: deleted, actionId });
+      return;
+    }
+    if (deleted) {
+      console.log(`Cleared cache for ${pc10.cyan(actionId)}`);
+    } else {
+      console.log(`No cache entry found for ${pc10.dim(actionId)}`);
+    }
+  } else {
+    const count = clearAll();
+    if (isAgentMode()) {
+      json({ cleared: true, count });
+      return;
+    }
+    console.log(`Cleared ${count} cached ${count === 1 ? "entry" : "entries"}`);
+  }
+}
+async function cacheListCommand(options) {
+  const entries = listCacheEntries();
+  const filtered = options.expired ? entries.filter((e) => !isFresh(e.entry)) : entries;
+  if (isAgentMode()) {
+    json({
+      entries: filtered.map((e) => ({
+        type: e.type,
+        key: e.entry.key,
+        cachedAt: e.entry.cachedAt,
+        age: formatAge(getAge(e.entry)),
+        ttl: e.entry.ttl,
+        fresh: isFresh(e.entry),
+        etag: e.entry.etag,
+        path: e.filePath
+      }))
+    });
+    return;
+  }
+  if (filtered.length === 0) {
+    console.log(options.expired ? "No expired cache entries" : "No cached entries");
+    return;
+  }
+  const rows = filtered.map((e) => ({
+    type: e.type,
+    key: e.entry.key,
+    age: formatAge(getAge(e.entry)),
+    status: isFresh(e.entry) ? pc10.green("fresh") : pc10.yellow("expired")
+  }));
+  printTable(
+    [
+      { key: "type", label: "Type" },
+      { key: "key", label: "Key" },
+      { key: "age", label: "Age" },
+      { key: "status", label: "Status" }
+    ],
+    rows
+  );
+}
+async function cacheUpdateAllCommand() {
+  const apiKey = getApiKey();
+  if (!apiKey) {
+    error("Not configured. Run `one init` first.");
+  }
+  const api = new OneApi(apiKey, getApiBase());
+  const entries = listCacheEntries();
+  if (entries.length === 0) {
+    if (isAgentMode()) {
+      json({ updated: 0, failed: 0, entries: [] });
+      return;
+    }
+    console.log("No cached entries to update");
+    return;
+  }
+  const spinner5 = createSpinner();
+  spinner5.start(`Updating ${entries.length} cached ${entries.length === 1 ? "entry" : "entries"}...`);
+  let updated = 0;
+  let failed = 0;
+  const errors = [];
+  for (const e of entries) {
+    try {
+      if (e.type === "knowledge") {
+        const result = await api.getActionKnowledgeWithMeta(e.entry.key);
+        const newEntry = makeCacheEntry(e.entry.key, result.data, result.etag);
+        writeCache2(e.filePath, newEntry);
+        updated++;
+      } else {
+        const refreshed = { ...e.entry, cachedAt: (/* @__PURE__ */ new Date()).toISOString() };
+        writeCache2(e.filePath, refreshed);
+        updated++;
+      }
+    } catch (err) {
+      failed++;
+      errors.push({
+        key: e.entry.key,
+        error: err instanceof Error ? err.message : "Unknown error"
+      });
+    }
+  }
+  spinner5.stop(`Updated ${updated} ${updated === 1 ? "entry" : "entries"}${failed > 0 ? `, ${failed} failed` : ""}`);
+  if (isAgentMode()) {
+    json({ updated, failed, errors: errors.length > 0 ? errors : void 0 });
+    return;
+  }
+  if (errors.length > 0) {
+    console.log();
+    for (const e of errors) {
+      console.log(`  ${pc10.red("\u2717")} ${e.key}: ${pc10.dim(e.error)}`);
+    }
+  }
+}
+
+// src/commands/guide.ts
+import pc11 from "picocolors";
+
+// src/lib/guide-content.ts
+var GUIDE_OVERVIEW = `# One CLI \u2014 Agent Guide
+
+## Setup
+
+1. Run \`one init\` to configure your API key (interactive \u2014 can be global or per-project)
+2. Run \`one add <platform>\` to connect platforms via OAuth
+3. Run \`one --agent connection list\` to verify connections
+
+## The --agent Flag
+
+Always use \`--agent\` for machine-readable JSON output. It disables colors, spinners, and interactive prompts.
+
+\`\`\`bash
+one --agent <command>
 \`\`\`
 
 All commands return JSON. If an \`error\` key is present, the command failed.
@@ -4060,6 +7587,10 @@ one --agent actions execute <platform> <actionId> <key> -d '{}'  # Execute it
 - \`--query-params <json>\` \u2014 Query parameters (arrays expand to repeated params)
 - \`--form-url-encoded\` \u2014 Send as form data instead of JSON
 - \`--dry-run\` \u2014 Preview request without executing
+- \`--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
+
+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.
 
 Do NOT pass path or query parameters in \`-d\` \u2014 use the correct flags.
 
@@ -4080,7 +7611,8 @@ one --agent flow list                                 # List all workflows
 - 12 step types: action, transform, code, condition, loop, parallel, file-read, file-write, while, flow, paginate, bash
 - Data wiring via selectors: \`$.input.param\`, \`$.steps.stepId.response\`, \`$.loop.item\`
 - AI analysis via bash steps: \`claude --print\` with \`parseJson: true\`
-- Use \`--allow-bash\` to enable bash steps, \`--mock\` for dry-run with mock responses
+- Use \`--allow-bash\` to enable bash steps, \`--mock\` for dry-run with realistic mock responses (uses example data from action schemas)
+- Use \`--skip-validation\` to bypass input validation on action steps
 
 ### 3. Relay \u2014 Webhook event forwarding between platforms
 Receive webhooks from platforms (Stripe, GitHub, Airtable, Attio, Google Calendar) and forward event data to any connected platform using passthrough actions with Handlebars templates. No middleware, no code.
@@ -4101,6 +7633,9 @@ one --agent relay deliveries --endpoint-id <id>                 # Check delivery
 - \`--create-webhook\` auto-registers the webhook URL with the source platform
 - Use \`actions knowledge\` to learn both the incoming payload shape AND the destination API shape before building templates
 
+### 4. Sync \u2014 Local data sync for instant offline queries
+Sync platform data into local SQLite for instant queries, full-text search, and change-driven automation. Requires a one-time \`one sync install\`. Run \`one guide sync\` for the full reference.
+
 ## Topics
 
 Request specific sections:
@@ -4109,6 +7644,7 @@ Request specific sections:
 - \`one guide flows\` \u2014 Workflow engine reference (step types, selectors, examples)
 - \`one guide relay\` \u2014 Webhook relay reference (templates, passthrough actions)
 - \`one guide cache\` \u2014 Cache management (TTL, flags, commands)
+- \`one guide sync\` \u2014 Data sync reference (profiles, pagination, queries)
 - \`one guide all\` \u2014 Everything
 
 ## Important Notes
@@ -4174,9 +7710,38 @@ one --agent actions execute <platform> <actionId> <connectionKey> [options]
 - \`--headers <json>\` \u2014 Additional headers
 - \`--form-data\` / \`--form-url-encoded\` \u2014 Alternative content types
 - \`--dry-run\` \u2014 Preview without executing
+- \`--mock\` \u2014 Return example response without making an API call
+- \`--skip-validation\` \u2014 Skip input validation against the action schema
 
 **Do NOT** pass path or query parameters in \`-d\`. Use the correct flags.
 
+### 4b. Parallel Execute
+
+Execute multiple actions concurrently in a single command:
+
+\`\`\`bash
+one --agent actions execute --parallel \\
+  gmail send-email conn123 -d '{"to":"a@b.com"}' \\
+  -- slack post-message conn456 -d '{"text":"done"}' \\
+  -- 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.
+
+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:
+\`\`\`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":{...}}]}
+\`\`\`
+
+## Input Validation
+
+The CLI validates required parameters before executing. Missing params return a structured error:
+\`\`\`json
+{"error": "Validation failed: missing required parameters", "validation": {"missing": [{"flag": "--path-vars", "param": "userId", "description": "..."}]}, "hint": "...pass --skip-validation to bypass..."}
+\`\`\`
+
 ## Error Handling
 
 All errors return JSON: \`{"error": "message"}\`. Check the \`error\` key.
@@ -4350,12 +7915,282 @@ All cache commands respect \`--agent\` for JSON output.
 | TTL (seconds) | \`cacheTtl\` in \`~/.one/config.json\` | \`"cacheTtl": 7200\` |
 | Default | \u2014 | 3600 (1 hour) |
 `;
+var GUIDE_SYNC = `# One Sync \u2014 Reference
+
+Sync platform data into local SQLite for instant queries, full-text search, scheduled refresh, and change-driven automation.
+
+## Getting Started
+
+\`\`\`bash
+one sync install                    # One-time: install the SQLite engine
+one sync doctor                     # Verify it's working
+\`\`\`
+
+## Built-in Profiles
+
+Pre-validated sync configs ship with the CLI for common platforms. Discover them:
+
+\`\`\`bash
+one --agent sync profiles              # list all built-in profiles
+one --agent sync profiles stripe       # filter by platform
+\`\`\`
+
+When a built-in exists, \`sync init\` uses it automatically \u2014 no inference needed, no manual config. The agent just needs to match the user's intent to a profile description.
+
+## Action Resolution
+
+Sync profiles MUST prefer passthrough actions over custom actions.
+Custom actions add server-side fan-out and transformation that causes timeouts
+and payload size failures at scale. The sync engine handles pagination, retries,
+rate limiting, and enrichment locally \u2014 a server-side middleware layer on top
+of that creates problems, not value.
+
+When resolving actions for sync profiles:
+1. Search with knowledge mode (not execute mode) to include passthrough actions
+2. Prefer GET passthrough endpoints (e.g. /gmail/v1/users/{userId}/threads)
+   over POST custom endpoints (e.g. /gmail/get-threads)
+3. Use enrich config for per-record detail fetching instead of relying on
+   custom actions that fan out server-side
+4. Only fall back to custom actions when no passthrough equivalent exists
+
+This applies to sync models discovery, sync init, and enrich action selection.
+
+## Workflow: init \u2192 run \u2192 query
+
+\`\`\`bash
+# 1. Discover models
+one --agent sync models stripe
+
+# 2. Init \u2014 one command does everything:
+#    - resolves action ID
+#    - infers pagination, resultsPath, idField, pathVars from knowledge
+#    - auto-resolves connectionKey (when only one connection exists)
+#    - auto-runs sync test if profile is complete
+one --agent sync init stripe balanceTransactions
+# Response includes _complete:true and _test results when fully resolved.
+# If connectionKey wasn't auto-resolved (multiple connections), patch it:
+one --agent sync init stripe balanceTransactions --config '{"connectionKey":"<from one list>"}'
+
+# 3. Sync
+one --agent sync run stripe
+
+# 4. Query
+one --agent sync query stripe/balanceTransactions --where "status=available" --limit 20
+one --agent sync search "refund" --platform stripe
+one --agent sync sql stripe "SELECT count(*) FROM balanceTransactions"
+\`\`\`
+
+## Auto-Inference
+
+\`sync init\` without \`--config\` does all of this automatically:
+- **connectionKey** \u2014 auto-resolved when there's exactly one connection for the platform
+- **Pagination** \u2014 Stripe id-pagination, Notion body-cursor, HubSpot/Google token, offset, link. Inapplicable fields stripped (no nextPath for offset, no passAs for none)
+- **resultsPath** \u2014 generic keys (data, results, items) + platform-specific (model name stripped of platform prefix: attioCompanies \u2192 companies)
+- **idField** \u2014 id, _id, uuid
+- **pathVars** \u2014 extracted from URL template with smart defaults (calendarId="primary", userId="me"). Internal keys (INTERNAL_SIGNING_KEY) and record-level IDs (record_id) are stripped automatically
+- **dateFilter** \u2014 updated_since, created_after, etc.
+- **limitLocation** \u2014 auto-detected as "body" for POST endpoints
+
+When the profile is complete (no FILL_IN values remain), \`sync init\` automatically runs \`sync test\` and includes the results in the response (\`_test: {ok, checks, autoFixed}\`). If test auto-discovers fields the inference missed, it patches the profile on disk.
+
+## Scheduled Syncs
+
+\`\`\`bash
+one sync schedule add stripe --every 1h
+one sync schedule add notion --every 30m --models search
+one --agent sync schedule list            # Works from any directory
+one --agent sync schedule status          # Drift detection + log tails
+one sync schedule remove <id|platform>    # By id (any dir) or platform
+one sync schedule repair <id>             # Re-install broken cron line
+\`\`\`
+Backed by system cron (macOS/Linux). Schedules tracked in a global registry at \`~/.one/sync/schedules.json\`.
+
+## Record Enrichment
+
+When a list endpoint returns lightweight records (e.g. just IDs), add an \`enrich\` config to call a detail endpoint per record and merge the full data before storing:
+
+\`\`\`json
+{
+  "enrich": {
+    "actionId": "<get-message-action-id>",
+    "pathVars": { "messageId": "{{id}}" },
+    "concurrency": 3,
+    "delayMs": 200
+  }
+}
+\`\`\`
+
+- \`pathVars\` / \`queryParams\` / \`body\` support \`{{field}}\` interpolation from the list record
+- \`concurrency\` controls parallel detail requests per page (default: 3, lower = safer for rate limits)
+- \`delayMs\` is the pause between batches (default: 200ms)
+- \`resultsPath\` extracts a sub-object from the detail response before merging
+- \`merge: false\` replaces the record entirely instead of deep-merging
+
+**Rate limiting is first-class:**
+- Honors \`Retry-After\` headers from 429 responses
+- Exponential backoff (2s \u2192 4s \u2192 8s)
+- Adaptive throttle: if any request in a batch hits 429, concurrency halves automatically
+- Records that fail after 3 retries are skipped (sync continues, count reported in \`enrichSkipped\`)
+
+**Important:** \`enrich.resultsPath\` operates on the raw API response, NOT the CLI's \`{dryRun, request, response}\` wrapper you see when testing with \`one --agent actions execute\`. If the CLI shows your data at \`response.thread\`, the enrich resultsPath is just \`"thread"\` (no \`response.\` prefix).
+
+Enrichment runs after list sync completes (Phase 2), not inline. It's inherently resumable \u2014 records track an \`_enriched_at\` timestamp, and re-running skips already-enriched rows.
+
+**Limitation:** Each profile supports one enrich action. If you need multiple enrichments (e.g. both summary and transcript from Fathom), create a second profile/model for the second enrichment.
+
+## Record Transform
+
+Pipe records through any shell command or flow between fetch and store. The command receives a JSON array on stdin and must return a JSON array on stdout.
+
+\`\`\`json
+{
+  "transform": "jq '[.[] | . + {flat_title: (.properties.title.title[0].plain_text // null)}]'"
+}
+\`\`\`
+
+Use cases:
+- Flatten nested fields into queryable top-level columns
+- Add computed fields (tags, categories, scores)
+- Filter out records you don't want to store
+- Reshape API responses into a cleaner schema
+
+The transform can be any command: \`jq\`, \`python3\`, a bash script, or \`one flow execute <key>\`. If the command fails, times out (60s), or returns invalid JSON, the original records are used (warning printed, sync continues).
+
+**Pipeline order:** fetch \u2192 enrich \u2192 transform \u2192 **exclude** \u2192 create table \u2192 schema evolution \u2192 upsert \u2192 hooks
+
+## Cross-Platform Identity
+
+Add \`identityKey\` to a sync profile to extract a stable cross-platform identifier (e.g. email) into a normalized \`_identity\` column:
+
+\`\`\`json
+{"platform": "hubspot", "model": "contacts", "identityKey": "properties.email"}
+{"platform": "stripe",  "model": "customers", "identityKey": "email"}
+{"platform": "attio",   "model": "attioPeople", "identityKey": "email_addresses[0].email_address"}
+\`\`\`
+
+The value is lowercased and trimmed. Query across platforms:
+\`\`\`bash
+one --agent sync sql hubspot "SELECT * FROM contacts WHERE _identity = 'jane@acme.com'"
+one --agent sync sql stripe "SELECT * FROM customers WHERE _identity = 'jane@acme.com'"
+\`\`\`
+
+## Exclude Fields
+
+Strip large or unwanted fields from records before storing (e.g. base64 attachments, raw HTML bodies):
+
+\`\`\`json
+{ "exclude": ["messages[].body", "messages[].attachments[].data", "payload.parts"] }
+\`\`\`
+
+Supports dot-path notation and array iteration (\`messages[].body\` strips \`body\` from each element of the \`messages\` array). Runs before table creation so excluded columns never exist in the schema.
+
+## Monitoring Progress
+
+\`sync list\` doubles as a progress monitor. The state file is updated after every page, so while a sync is running you can check progress from another context:
+
+\`\`\`bash
+one --agent sync list gmail
+# \u2192 {"syncs":[{"model":"gmailThreads","totalRecords":400,"pagesProcessed":8,"status":"syncing",...}]}
+\`\`\`
+
+When \`status\` is \`"syncing"\`, \`totalRecords\` and \`pagesProcessed\` reflect real-time progress. When it flips to \`"idle"\`, the sync is done. No need to babysit \u2014 especially when using \`sync schedule\` for unattended runs.
+
+## Change Hooks (CDC)
+
+Add \`onInsert\`, \`onUpdate\`, or \`onChange\` to a sync profile to fire hooks when records change:
+
+\`\`\`json
+{
+  "onInsert": "one flow execute enrich-new-contact",
+  "onUpdate": "log",
+  "onChange": "node ./scripts/handle-change.js"
+}
+\`\`\`
+
+**Hook modes:**
+- **Shell command** \u2014 record events piped as NDJSON to stdin
+- **\`"log"\`** \u2014 append to \`.one/sync/events/<platform>_<model>.jsonl\`
+- **Flow execution** \u2014 \`one flow execute <key>\` with record as input
+
+Hooks fire after each page (not end-of-sync) for real-time processing. Each event:
+\`{"type":"insert|update","platform":"...","model":"...","record":{...},"timestamp":"..."}\`
+
+Every record has a \`_synced_at\` timestamp so you can track when it was last pulled.
+
+## Full Refresh (deletion detection)
+
+\`\`\`bash
+one --agent sync run stripe --full-refresh
+\`\`\`
+Fetches ALL records and deletes local rows whose IDs are no longer in the source. Cannot be combined with \`--since\`.
+
+## Commands Reference
+
+| Command | What it does |
+|---------|-------------|
+| \`sync profiles [platform]\` | List built-in pre-validated profiles |
+| \`sync install\` | Install SQLite engine (first time) |
+| \`sync doctor\` | Verify engine health |
+| \`sync models <platform>\` | Discover available models |
+| \`sync init <plat> <model>\` | Create profile (auto-infers from knowledge) |
+| \`sync test <plat>/<model>\` | Validate profile + auto-fix fields |
+| \`sync run <platform>\` | Sync data (\`--full-refresh\`, \`--since\`, \`--dry-run\`) |
+| \`sync query <plat>/<model>\` | Query with \`--where\`, \`--after/before\`, \`--refresh\` |
+| \`sync search "<query>"\` | FTS5 across all synced data |
+| \`sync sql <plat> "<sql>"\` | Raw SELECT queries |
+| \`sync list [platform]\` | Show profiles, record counts, freshness |
+| \`sync schedule add/list/status/remove/repair\` | Manage cron schedules |
+| \`sync remove <platform>\` | Delete local data (\`--dry-run\` to preview) |
+
+## Sync Profile Fields
+
+| Field | Required | Description |
+|-------|----------|-------------|
+| connectionKey | yes | From \`one list\` |
+| actionId | yes | Auto-resolved by \`sync init\` |
+| resultsPath | yes | Auto-inferred or auto-discovered by \`sync test\` |
+| idField | yes | Auto-inferred or auto-discovered by \`sync test\` |
+| pagination | yes | Auto-inferred (cursor/token/offset/id/link/none) |
+| pathVars | no | Auto-extracted from URL template |
+| dateFilter | no | For incremental sync (auto-detected when available) |
+| limitParam | no | Page size param name (empty string = don't send) |
+| limitLocation | no | "query" (default) or "body" for POST endpoints |
+| enrich | no | Detail endpoint config for record enrichment (actionId, pathVars, concurrency) |
+| transform | no | Shell command to transform records (stdin: JSON array, stdout: JSON array) |
+| identityKey | no | Dot-path to cross-platform identifier (e.g. email) \u2192 stored as \`_identity\` column |
+| exclude | no | Dot-path fields to strip before storing (e.g. \`["messages[].body"]\`) |
+| onInsert/onUpdate/onChange | no | Change hooks (shell command, "log", or flow) |
+
+## Pagination Types
+
+- **cursor** \u2014 \`{"type":"cursor", "nextPath":"next_cursor", "passAs":"query:cursor"}\`
+- **token** \u2014 \`{"type":"token", "nextPath":"paging.next.after", "passAs":"query:after"}\`
+- **offset** \u2014 \`{"type":"offset", "passAs":"query:offset", "totalPath":"total"}\`
+- **id** \u2014 \`{"type":"id", "passAs":"query:starting_after", "hasMorePath":"has_more"}\`
+- **link** \u2014 \`{"type":"link", "nextPath":"link.next.page_info", "passAs":"query:page_info"}\`
+- **none** \u2014 single request, no pagination (no limit param injected)
+
+## File Layout
+
+\`\`\`
+.one/sync/
+  profiles/{platform}_{model}.json    # sync profiles
+  data/{platform}.db                  # SQLite databases (WAL mode)
+  sync_state.json                     # checkpoint tracking
+  events/{platform}_{model}.jsonl     # change event logs (if onChange: "log")
+  logs/{platform}.log                 # cron run logs
+  locks/{platform}_{model}/           # cross-process sync locks
+~/.one/sync/
+  schedules.json                      # global schedule registry
+\`\`\`
+`;
 var TOPICS = [
   { topic: "overview", description: "Setup, features, and quick start for each" },
   { topic: "actions", description: "Search, read docs, and execute platform actions" },
   { topic: "flows", description: "Build and execute multi-step workflows" },
   { topic: "relay", description: "Receive webhooks and forward to other platforms" },
   { topic: "cache", description: "Local caching for knowledge and search responses" },
+  { topic: "sync", description: "Sync platform data locally for instant offline queries" },
   { topic: "all", description: "Complete guide (all topics combined)" }
 ];
 function getGuideContent(topic) {
@@ -4370,10 +8205,12 @@ function getGuideContent(topic) {
       return { title: "One CLI \u2014 Agent Guide: Relay", content: GUIDE_RELAY };
     case "cache":
       return { title: "One CLI \u2014 Agent Guide: Cache", content: GUIDE_CACHE };
+    case "sync":
+      return { title: "One CLI \u2014 Agent Guide: Sync", content: GUIDE_SYNC };
     case "all":
       return {
         title: "One CLI \u2014 Agent Guide: Complete",
-        content: [GUIDE_OVERVIEW, GUIDE_ACTIONS, GUIDE_FLOWS, GUIDE_RELAY, GUIDE_CACHE].join("\n---\n\n")
+        content: [GUIDE_OVERVIEW, GUIDE_ACTIONS, GUIDE_FLOWS, GUIDE_RELAY, GUIDE_CACHE, GUIDE_SYNC].join("\n---\n\n")
       };
   }
 }
@@ -4382,7 +8219,7 @@ function getAvailableTopics() {
 }
 
 // src/commands/guide.ts
-var VALID_TOPICS = ["overview", "actions", "flows", "relay", "cache", "all"];
+var VALID_TOPICS = ["overview", "actions", "flows", "relay", "cache", "sync", "all"];
 async function guideCommand(topic = "all") {
   if (!VALID_TOPICS.includes(topic)) {
     error(
@@ -4395,14 +8232,14 @@ async function guideCommand(topic = "all") {
     json({ topic, title, content, availableTopics });
     return;
   }
-  intro2(pc10.bgCyan(pc10.black(" One Guide ")));
+  intro2(pc11.bgCyan(pc11.black(" One Guide ")));
   console.log();
   console.log(content);
-  console.log(pc10.dim("\u2500".repeat(60)));
+  console.log(pc11.dim("\u2500".repeat(60)));
   console.log(
-    pc10.dim("Available topics: ") + availableTopics.map((t) => pc10.cyan(t.topic)).join(", ")
+    pc11.dim("Available topics: ") + availableTopics.map((t) => pc11.cyan(t.topic)).join(", ")
   );
-  console.log(pc10.dim(`Run ${pc10.cyan("one guide <topic>")} for a specific section.`));
+  console.log(pc11.dim(`Run ${pc11.cyan("one guide <topic>")} for a specific section.`));
 }
 
 // src/lib/platform-meta.ts
@@ -4441,7 +8278,7 @@ function pairKey(a, b) {
 }
 function getWorkflowExamples(connectedPlatforms) {
   const results = [];
-  const platforms = connectedPlatforms.map((p7) => p7.toLowerCase());
+  const platforms = connectedPlatforms.map((p8) => p8.toLowerCase());
   for (let i = 0; i < platforms.length; i++) {
     for (let j = i + 1; j < platforms.length; j++) {
       const key = pairKey(platforms[i], platforms[j]);
@@ -4685,13 +8522,13 @@ function buildDemoActions(connections) {
   const connectedPlatforms = connections.map((c) => c.platform.toLowerCase());
   const popularPlatforms = ["gmail", "google-calendar", "slack", "shopify", "hub-spot", "github"];
   const platformsToShow = [
-    ...connectedPlatforms.filter((p7) => PLATFORM_DEMO_ACTIONS[p7]),
-    ...popularPlatforms.filter((p7) => !connectedPlatforms.includes(p7))
+    ...connectedPlatforms.filter((p8) => PLATFORM_DEMO_ACTIONS[p8]),
+    ...popularPlatforms.filter((p8) => !connectedPlatforms.includes(p8))
   ];
   const seen = /* @__PURE__ */ new Set();
-  const unique = platformsToShow.filter((p7) => {
-    if (seen.has(p7)) return false;
-    seen.add(p7);
+  const unique = platformsToShow.filter((p8) => {
+    if (seen.has(p8)) return false;
+    seen.add(p8);
     return true;
   }).slice(0, 6);
   for (const platform of unique) {
@@ -4749,6 +8586,15 @@ program.name("one").option("--agent", "Machine-readable JSON output (no colors,
     one flow execute <key>                Execute a workflow
     one flow validate <key>               Validate a flow
 
+  Data Sync (run "one sync install" first, then "one guide sync" for full reference):
+    one sync models <platform>            Discover available data models
+    one sync init <plat> <model>          Create profile (auto-infers from knowledge)
+    one sync test <plat>/<model>          Validate + auto-fix profile fields
+    one sync run <platform>               Sync data (--full-refresh for deletions)
+    one sync query <plat>/<model>         Query local data (--where, --refresh)
+    one sync search "<query>"             Full-text search across all synced data
+    one sync schedule add <plat> --every  Cron schedule (e.g. 1h) with change hooks
+
   Cache:
     one cache list                        List cached entries with age and status
     one cache clear                       Clear all cached knowledge and search data
@@ -4901,7 +8747,14 @@ 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").description('Execute an action \u2014 pass connectionKey from "one list", actionId from "actions search"').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").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("--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;
+  }
+  if (!platform || !actionId || !connectionKey) {
+    error("Usage: one actions execute <platform> <actionId> <connectionKey> [-d ...]");
+  }
   await actionsExecuteCommand(platform, actionId, connectionKey, {
     data: options.data,
     pathVars: options.pathVars,
@@ -4909,14 +8762,16 @@ actions.command("execute <platform> <actionId> <connectionKey>").alias("x").desc
     headers: options.headers,
     formData: options.formData,
     formUrlEncoded: options.formUrlEncoded,
-    dryRun: options.dryRun
+    dryRun: options.dryRun,
+    mock: options.mock,
+    skipValidation: options.skipValidation
   });
 });
 var flow = program.command("flow").alias("f").description("Create, execute, and manage multi-step workflows");
 flow.command("create [key]").description("Create a new workflow from JSON definition").option("--definition <json>", "Workflow definition as JSON string").option("-o, --output <path>", "Custom output path (default .one/flows/<key>/flow.json)").action(async (key, options) => {
   await flowCreateCommand(key, options);
 });
-flow.command("execute <keyOrPath>").alias("x").description("Execute a workflow by key or file path").option("-i, --input <name=value>", "Input parameter (repeatable)", collect, []).option("--dry-run", "Validate and show execution plan without running").option("--mock", "With --dry-run: execute transforms/code with mock API responses").option("--allow-bash", "Allow bash step execution (disabled by default for security)").option("-v, --verbose", "Show full request/response for each step").action(async (keyOrPath, options) => {
+flow.command("execute <keyOrPath>").alias("x").description("Execute a workflow by key or file path").option("-i, --input <name=value>", "Input parameter (repeatable)", collect, []).option("--dry-run", "Validate and show execution plan without running").option("--mock", "With --dry-run: execute transforms/code with realistic mock API responses").option("--skip-validation", "Skip input validation against action schemas").option("--allow-bash", "Allow bash step execution (disabled by default for security)").option("-v, --verbose", "Show full request/response for each step").action(async (keyOrPath, options) => {
   await flowExecuteCommand(keyOrPath, options);
 });
 flow.command("list").alias("ls").description("List all workflows in .one/flows/").action(async () => {
@@ -4965,6 +8820,7 @@ relay.command("deliveries").description("List delivery attempts for an endpoint
 relay.command("event-types <platform>").description("List supported webhook event types for a platform").action(async (platform) => {
   await relayEventTypesCommand(platform);
 });
+registerSyncCommands(program);
 var cache = program.command("cache").description("Manage the local knowledge and search cache");
 cache.command("clear [actionId]").description("Clear all cached data, or a specific action by ID").action(async (actionId) => {
   await cacheClearCommand(actionId);
@@ -4975,7 +8831,7 @@ cache.command("list").alias("ls").description("List all cached entries with age
 cache.command("update-all").description("Re-fetch fresh data for all cached entries").action(async () => {
   await cacheUpdateAllCommand();
 });
-program.command("guide [topic]").description("Full CLI usage guide for agents (topics: overview, actions, flows, relay, all)").action(async (topic) => {
+program.command("guide [topic]").description("Full CLI usage guide for agents (topics: overview, actions, flows, relay, cache, sync, all)").action(async (topic) => {
   await guideCommand(topic);
 });
 program.command("onboard").description("Agent onboarding \u2014 teaches your agent what the One CLI can do").option("--step <number>", "Run a specific onboarding step (1, 2, or 3)").action(async (options) => {