@withone/cli 2.14.1 → 2.14.4

package/dist/index.js

@@ -40,16 +40,18 @@ import {
   validateActionInput,
   walkSteps,
   writeCache
-} from "./chunk-IM3OA7CU.js";
+} from "./chunk-33KUKSRH.js";
 import {
   memSqlCommand
 } from "./chunk-TSMVFVQ3.js";
 import {
+  assertSafeSyncNames,
   collectIdentityKeys,
   countRecords,
   deleteDatabase,
   deleteRecords,
   dropTable,
+  ensureDirInsideProject,
   ensureTable,
   evolveSchema,
   extractSearchableFromPaths,
@@ -74,7 +76,7 @@ import {
   writeDraftProfile,
   writePageToMemory,
   writeProfile
-} from "./chunk-LEJKEGB6.js";
+} from "./chunk-AFZIE2QJ.js";
 import {
   getByDotPath
 } from "./chunk-44CV5IMX.js";
@@ -156,7 +158,7 @@ import {
 
 // src/cli.ts
 import { createRequire } from "module";
-import path14 from "path";
+import path15 from "path";
 import { Command } from "commander";
 
 // src/commands/init.ts
@@ -1288,13 +1290,13 @@ async function chooseConfigScope(options) {
   const resolved = resolveConfig();
   const hasGlobal = globalConfigExists();
   const hasProject = projectConfigExists();
-  const projectRoot = resolved.projectRoot;
-  const projectName = path2.basename(projectRoot);
+  const projectRoot2 = resolved.projectRoot;
+  const projectName = path2.basename(projectRoot2);
   const homeGlobal = tildify(getGlobalConfigPath());
-  const homeProject = tildify(getProjectConfigPath(projectRoot));
+  const homeProject = tildify(getProjectConfigPath(projectRoot2));
   if (hasProject) {
     console.log();
-    console.log(`  ${pc3.dim("Project:")}  ${projectName}   ${pc3.dim(projectRoot)}`);
+    console.log(`  ${pc3.dim("Project:")}  ${projectName}   ${pc3.dim(projectRoot2)}`);
     console.log(`  ${pc3.bold("Active config:")} ${pc3.cyan("project")} ${pc3.dim("\xB7 " + homeProject)}`);
     console.log();
     if (hasGlobal) {
@@ -1314,7 +1316,7 @@ async function chooseConfigScope(options) {
   console.log();
   console.log(`  ${pc3.bold("Initializing One")}`);
   console.log(`  ${pc3.dim("\u2500".repeat(42))}`);
-  console.log(`  ${pc3.dim("Project:")}  ${projectName}   ${pc3.dim(projectRoot)}`);
+  console.log(`  ${pc3.dim("Project:")}  ${projectName}   ${pc3.dim(projectRoot2)}`);
   console.log(`  ${pc3.dim("Global:")}   ${hasGlobal ? pc3.green("\u2713 configured") : pc3.yellow("\u2014 not set up")}   ${pc3.dim(homeGlobal)}`);
   console.log(`  ${pc3.dim("Project:")}  ${pc3.yellow("\u2014 not set up")}   ${pc3.dim(homeProject)}`);
   console.log();
@@ -3325,7 +3327,7 @@ var CUSTOM_ACTION_NOTE = '\n\nThis is a custom action: ALSO include "connectionK
 function codeGuideAction(action, knowledge, platform, tags, apiBase) {
   const base = apiBase.replace(/\/$/, "");
   const method = action.method.toUpperCase();
-  const path15 = action.path.startsWith("/") ? action.path : `/${action.path}`;
+  const path16 = action.path.startsWith("/") ? action.path : `/${action.path}`;
   const connEnv = `ONE_${platformEnvSegment(platform)}_CONNECTION_KEY`;
   const customNote = tags.includes("custom") ? CUSTOM_ACTION_NOTE : "";
   return `### ${actionHeading(action)}
@@ -3334,7 +3336,7 @@ function codeGuideAction(action, knowledge, platform, tags, apiBase) {
 ${knowledge ?? NO_KNOWLEDGE}
 
 ## Calling this action from code
-URL:    ${base}/passthrough${path15}
+URL:    ${base}/passthrough${path16}
 Method: ${method}
 Headers:
 - x-one-secret: the value of the ONE_SECRET env var
@@ -3345,7 +3347,7 @@ Headers:
 Environment variables: ONE_SECRET (their One API key) and ${connEnv} (the key of their ${platform} connection), both from the One dashboard.
 
 \`\`\`typescript
-const response = await fetch("${base}/passthrough${path15}", {
+const response = await fetch("${base}/passthrough${path16}", {
 method: "${method}",
 headers: {
 "x-one-secret": process.env.ONE_SECRET,
@@ -4095,32 +4097,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 path15 = `${pathPrefix}[${i}]`;
+    const path16 = `${pathPrefix}[${i}]`;
     if (!step || typeof step !== "object" || Array.isArray(step)) {
-      errors.push({ path: path15, 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: `${path15}.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: `${path15}.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: `${path15}.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: `${path15}.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: `${path15}.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: `${path15}.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")` });
           }
         }
       }
@@ -4128,7 +4130,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: `${path15}.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);
@@ -4138,14 +4140,14 @@ function validateStepsArray(steps, pathPrefix, errors) {
     if (!configObj || typeof configObj !== "object") {
       const hint = detectFlatConfigHint(s, descriptor);
       errors.push({
-        path: `${path15}.${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 = `${path15}.${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}"` });
@@ -4178,30 +4180,30 @@ function validateStepsArray(steps, pathPrefix, errors) {
       }
     }
     if (descriptor.type === "action") {
-      validateConnectionForm(config2, `${path15}.${configKey}`, errors);
+      validateConnectionForm(config2, `${path16}.${configKey}`, errors);
     }
     if (descriptor.type === "code") {
       const hasSource = typeof config2.source === "string" && config2.source.length > 0;
       const hasModule = typeof config2.module === "string" && config2.module.length > 0;
       if (!hasSource && !hasModule) {
-        errors.push({ path: `${path15}.${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: `${path15}.${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: `${path15}.${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: `${path15}.${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: `${path15}.${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: `${path15}.${configKey}.source`, message: `Syntax error in code step: ${syntaxError}` });
+          errors.push({ path: `${path16}.${configKey}.source`, message: `Syntax error in code step: ${syntaxError}` });
         }
       }
     }
@@ -4273,16 +4275,16 @@ function validateStepIds(flow2) {
   function collectIds(steps, pathPrefix) {
     for (let i = 0; i < steps.length; i++) {
       const step = steps[i];
-      const path15 = `${pathPrefix}[${i}]`;
+      const path16 = `${pathPrefix}[${i}]`;
       if (seen.has(step.id)) {
-        errors.push({ path: `${path15}.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], `${path15}.${configKey}.${fieldName}`);
+          collectIds(config2[fieldName], `${path16}.${configKey}.${fieldName}`);
         }
       }
     }
@@ -4330,7 +4332,7 @@ function validateSelectorReferences(flow2, rootDir) {
     }
     return selectors;
   }
-  function checkSelectors(selectors, path15, precedingStepIds) {
+  function checkSelectors(selectors, path16, precedingStepIds) {
     for (const selector of selectors) {
       const parts = selector.split(".");
       if (parts.length < 3) continue;
@@ -4338,15 +4340,15 @@ function validateSelectorReferences(flow2, rootDir) {
       if (root === "input") {
         const inputName = parts[2];
         if (!inputNames.has(inputName)) {
-          errors.push({ path: path15, 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: path15, 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: path15,
+            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.`
           });
         }
@@ -4354,20 +4356,20 @@ function validateSelectorReferences(flow2, rootDir) {
     }
   }
   const EXPRESSION_FIELDS = /* @__PURE__ */ new Set(["condition.expression", "while.condition"]);
-  function checkOperatorsInSelectorField(value, path15) {
+  function checkOperatorsInSelectorField(value, path16) {
     if (typeof value === "string" && value.startsWith("$.")) {
       if (value.includes("||")) {
-        errors.push({ path: path15, 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: path15, 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, `${path15}.${k}`);
+        checkOperatorsInSelectorField(v, `${path16}.${k}`);
       }
     } else if (Array.isArray(value)) {
       for (let i = 0; i < value.length; i++) {
-        checkOperatorsInSelectorField(value[i], `${path15}[${i}]`);
+        checkOperatorsInSelectorField(value[i], `${path16}[${i}]`);
       }
     }
   }
@@ -4452,10 +4454,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, path15) {
+function walkOutputSchema(schema, path16) {
   let current = schema;
-  for (let i = 0; i < path15.length; i++) {
-    const seg = path15[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";
     }
@@ -6725,8 +6727,32 @@ import path8 from "path";
 var LOCK_DIR_REL = path8.join(".one", "sync", "locks");
 var STALE_MS = 30 * 60 * 1e3;
 function lockPath(platform, model) {
+  try {
+    assertSafeSyncNames(platform, model);
+  } catch (err) {
+    throw new SyncLockError(err instanceof Error ? err.message : String(err));
+  }
   return path8.join(LOCK_DIR_REL, `${platform}_${model}`);
 }
+var PID_FILE = "pid";
+function looksLikeOurLock(dir) {
+  try {
+    if (!fs8.lstatSync(dir).isDirectory()) return false;
+    const entries = fs8.readdirSync(dir);
+    if (!entries.every((e) => e === PID_FILE)) return false;
+    if (entries.length === 1 && !fs8.lstatSync(path8.join(dir, PID_FILE)).isFile()) return false;
+    return true;
+  } catch {
+    return false;
+  }
+}
+function removeLockDir(dir) {
+  try {
+    fs8.unlinkSync(path8.join(dir, PID_FILE));
+  } catch {
+  }
+  fs8.rmdirSync(dir);
+}
 function isProcessAlive(pid) {
   try {
     process.kill(pid, 0);
@@ -6742,15 +6768,19 @@ var SyncLockError = class extends Error {
   }
 };
 function acquireSyncLock(platform, model) {
-  fs8.mkdirSync(LOCK_DIR_REL, { recursive: true });
   const dir = lockPath(platform, model);
-  const pidFile = path8.join(dir, "pid");
+  try {
+    ensureDirInsideProject(LOCK_DIR_REL);
+  } catch (err) {
+    throw new SyncLockError(err instanceof Error ? err.message : String(err));
+  }
+  const pidFile = path8.join(dir, PID_FILE);
   try {
     fs8.mkdirSync(dir);
   } catch (err) {
     const stat = (() => {
       try {
-        return fs8.statSync(dir);
+        return fs8.lstatSync(dir);
       } catch {
         return null;
       }
@@ -6767,8 +6797,13 @@ function acquireSyncLock(platform, model) {
       const ownerDead = ownerPid !== null && !isProcessAlive(ownerPid);
       const veryOld = age > STALE_MS;
       if (ownerDead || veryOld) {
+        if (!looksLikeOurLock(dir)) {
+          throw new SyncLockError(
+            `${dir} exists but is not a sync lock. Remove it manually if no sync is running.`
+          );
+        }
         try {
-          fs8.rmSync(dir, { recursive: true, force: true });
+          removeLockDir(dir);
           fs8.mkdirSync(dir);
         } catch {
           throw new SyncLockError(
@@ -6792,7 +6827,7 @@ function acquireSyncLock(platform, model) {
   return {
     release() {
       try {
-        fs8.rmSync(dir, { recursive: true, force: true });
+        if (looksLikeOurLock(dir)) removeLockDir(dir);
       } catch {
       }
     }
@@ -6849,10 +6884,24 @@ async function fireHooks(hookCommand, events) {
 function appendEventLog(events) {
   if (events.length === 0) return;
   const { platform, model } = events[0];
-  fs9.mkdirSync(EVENTS_DIR, { recursive: true });
+  assertSafeSyncNames(platform, model);
+  ensureDirInsideProject(EVENTS_DIR);
   const logPath = path9.join(EVENTS_DIR, `${platform}_${model}.jsonl`);
   const lines = events.map((e) => JSON.stringify(e)).join("\n") + "\n";
-  fs9.appendFileSync(logPath, lines);
+  try {
+    if (fs9.lstatSync(logPath).isSymbolicLink()) {
+      throw new Error(`Refusing to append to ${logPath}: it is a symlink.`);
+    }
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+  const noFollow = fs9.constants.O_NOFOLLOW ?? 0;
+  const fd = fs9.openSync(logPath, fs9.constants.O_WRONLY | fs9.constants.O_APPEND | fs9.constants.O_CREAT | noFollow, 420);
+  try {
+    fs9.writeSync(fd, lines);
+  } finally {
+    fs9.closeSync(fd);
+  }
 }
 function runShellHook(command, events) {
   return new Promise((resolve) => {
@@ -6956,8 +7005,8 @@ function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 function interpolate(template, record) {
-  return template.replace(/\{?\{(\w+(?:\.\w+)*)\}\}?/g, (_, path15) => {
-    const parts = path15.split(".");
+  return template.replace(/\{?\{(\w+(?:\.\w+)*)\}\}?/g, (_, path16) => {
+    const parts = path16.split(".");
     let value = record;
     for (const part2 of parts) {
       if (typeof value !== "object" || value === null) return "";
@@ -6985,8 +7034,8 @@ function deepMerge(target, source) {
   }
   return result;
 }
-function getByDotPath2(obj, path15) {
-  const parts = path15.split(".");
+function getByDotPath2(obj, path16) {
+  const parts = path16.split(".");
   let current = obj;
   for (const part2 of parts) {
     if (current === null || current === void 0 || typeof current !== "object") return void 0;
@@ -6995,8 +7044,8 @@ function getByDotPath2(obj, path15) {
   return current;
 }
 function stripExcludedFields(obj, paths) {
-  for (const path15 of paths) {
-    stripOnePath(obj, path15.replace(/\[\]/g, ".*").split("."));
+  for (const path16 of paths) {
+    stripOnePath(obj, path16.replace(/\[\]/g, ".*").split("."));
   }
 }
 function stripOnePath(obj, parts) {
@@ -7353,6 +7402,88 @@ function detectColumnType(value) {
   return "TEXT";
 }
 
+// src/lib/memory/sync/approval.ts
+import crypto3 from "crypto";
+import fs10 from "fs";
+import path10 from "path";
+var SHELL_FIELDS = ["transform", "onInsert", "onUpdate", "onChange"];
+var STORE_FILE = () => path10.join(homeDir(), ".one", "sync", "shell-approvals.json");
+function shellCommandsOf(profile) {
+  const out = {};
+  for (const field of SHELL_FIELDS) {
+    const value = profile[field];
+    if (typeof value !== "string" || value.trim() === "") continue;
+    if (field !== "transform" && value === "log") continue;
+    out[field] = value;
+  }
+  return out;
+}
+function hashCommands(commands) {
+  const ordered = SHELL_FIELDS.map((f) => [f, commands[f] ?? null]);
+  return crypto3.createHash("sha256").update(JSON.stringify(ordered)).digest("hex");
+}
+function projectRoot() {
+  try {
+    return fs10.realpathSync(process.cwd());
+  } catch {
+    return path10.resolve(process.cwd());
+  }
+}
+function keyFor(platform, model) {
+  return `${projectRoot()}::${platform}/${model}`;
+}
+function readStore() {
+  try {
+    const parsed = JSON.parse(fs10.readFileSync(STORE_FILE(), "utf-8"));
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function writeStore(store) {
+  const file = STORE_FILE();
+  fs10.mkdirSync(path10.dirname(file), { recursive: true, mode: 448 });
+  const tmp = `${file}.${process.pid}.tmp`;
+  fs10.writeFileSync(tmp, JSON.stringify(store, null, 2), { mode: 384 });
+  fs10.renameSync(tmp, file);
+}
+function isShellApproved(profile) {
+  const commands = shellCommandsOf(profile);
+  if (Object.keys(commands).length === 0) return true;
+  const entry = readStore()[keyFor(profile.platform, profile.model)];
+  return !!entry && entry.hash === hashCommands(commands);
+}
+function approveShellCommands(profile) {
+  const store = readStore();
+  const key = keyFor(profile.platform, profile.model);
+  const commands = shellCommandsOf(profile);
+  if (Object.keys(commands).length === 0) {
+    if (!(key in store)) return;
+    delete store[key];
+  } else {
+    store[key] = { hash: hashCommands(commands), commands, approvedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  }
+  writeStore(store);
+}
+var SyncShellNotApprovedError = class extends Error {
+  constructor(profile, commands) {
+    const list = Object.entries(commands).map(([f, c]) => `  ${f}: ${c}`).join("\n");
+    super(
+      `Sync profile ${profile.platform}/${profile.model} runs shell commands that you haven't approved (or that changed since you approved them):
+${list}
+Review them, then run: one sync approve ${profile.platform} --models ${profile.model}`
+    );
+    this.profile = profile;
+    this.commands = commands;
+    this.name = "SyncShellNotApprovedError";
+  }
+};
+function assertShellApproved(profile) {
+  if (!isShellApproved(profile)) {
+    throw new SyncShellNotApprovedError(profile, shellCommandsOf(profile));
+  }
+}
+
 // src/lib/memory/sync/extract.ts
 var ROOT_PATH_TOKENS = /* @__PURE__ */ new Set(["", "$", "."]);
 function isRootPath(resultsPath) {
@@ -7417,8 +7548,8 @@ function sleep2(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 function stripFields(record, paths) {
-  for (const path15 of paths) {
-    stripOnePath2(record, path15.split("."));
+  for (const path16 of paths) {
+    stripOnePath2(record, path16.split("."));
   }
 }
 function stripOnePath2(obj, parts) {
@@ -7479,6 +7610,7 @@ async function syncModel(api, profile, options) {
       "--full-refresh and --since cannot be used together. --full-refresh always fetches the whole collection."
     );
   }
+  if (!options.dryRun) assertShellApproved(profile);
   const connectionKey = await resolveProfileConnectionKey(api, profile);
   const lock = options.dryRun ? null : acquireSyncLock(platform, model);
   const existingState = await getModelState(platform, model);
@@ -8511,19 +8643,19 @@ function inferProfileFromKnowledge(knowledge, modelName, platform) {
 
 // src/lib/memory/sync/schedule.ts
 import { spawnSync as spawnSync2 } from "child_process";
-import fs11 from "fs";
+import fs12 from "fs";
 import os from "os";
-import path11 from "path";
+import path12 from "path";
 
 // src/lib/memory/sync/schedule-registry.ts
-import fs10 from "fs";
-import path10 from "path";
-var REGISTRY_DIR = () => path10.join(homeDir(), ".one", "sync");
-var REGISTRY_FILE = () => path10.join(REGISTRY_DIR(), "schedules.json");
+import fs11 from "fs";
+import path11 from "path";
+var REGISTRY_DIR = () => path11.join(homeDir(), ".one", "sync");
+var REGISTRY_FILE = () => path11.join(REGISTRY_DIR(), "schedules.json");
 function readRaw() {
   try {
-    if (!fs10.existsSync(REGISTRY_FILE())) return { schedules: [] };
-    const raw = fs10.readFileSync(REGISTRY_FILE(), "utf-8");
+    if (!fs11.existsSync(REGISTRY_FILE())) return { schedules: [] };
+    const raw = fs11.readFileSync(REGISTRY_FILE(), "utf-8");
     const parsed = JSON.parse(raw);
     if (!parsed || !Array.isArray(parsed.schedules)) return { schedules: [] };
     return parsed;
@@ -8532,13 +8664,13 @@ function readRaw() {
   }
 }
 function writeRaw(file) {
-  fs10.mkdirSync(REGISTRY_DIR(), { recursive: true });
+  fs11.mkdirSync(REGISTRY_DIR(), { recursive: true });
   const tmp = REGISTRY_FILE() + ".tmp";
-  fs10.writeFileSync(tmp, JSON.stringify(file, null, 2));
-  fs10.renameSync(tmp, REGISTRY_FILE());
+  fs11.writeFileSync(tmp, JSON.stringify(file, null, 2));
+  fs11.renameSync(tmp, REGISTRY_FILE());
 }
 function makeScheduleId(platform, cwd) {
-  const slug = path10.basename(cwd).replace(/[^a-zA-Z0-9_-]/g, "-").toLowerCase();
+  const slug = path11.basename(cwd).replace(/[^a-zA-Z0-9_-]/g, "-").toLowerCase();
   return `${platform}-${slug}`;
 }
 function listRegistered() {
@@ -8572,7 +8704,7 @@ function removeRegistered(id) {
 
 // src/lib/memory/sync/schedule.ts
 var MARKER = "# one-sync";
-var LOG_DIR_REL = path11.join(".one", "sync", "logs");
+var LOG_DIR_REL = path12.join(".one", "sync", "logs");
 function durationToCron(every) {
   const match = every.match(/^(\d+)([mhd])$/);
   if (!match) return null;
@@ -8610,8 +8742,8 @@ function isWindows() {
 function resolveOneBinary() {
   try {
     const entry = process.argv[1];
-    if (entry && fs11.existsSync(entry)) {
-      return fs11.realpathSync(entry);
+    if (entry && fs12.existsSync(entry)) {
+      return fs12.realpathSync(entry);
     }
   } catch {
   }
@@ -8689,7 +8821,7 @@ function migrateLegacyCronEntries() {
     const modelsMatch = command.match(/--models\s+(\S+)/);
     const models = modelsMatch ? modelsMatch[1].split(",") : void 0;
     const logMatch = command.match(/>>\s+"([^"]+)"/);
-    const logFile = logMatch ? logMatch[1] : path11.resolve(cwd, LOG_DIR_REL, `${platform}.log`);
+    const logFile = logMatch ? logMatch[1] : path12.resolve(cwd, LOG_DIR_REL, `${platform}.log`);
     const id = makeScheduleId(platform, cwd);
     if (registeredIds.has(id)) continue;
     upsertRegistered({
@@ -8723,9 +8855,9 @@ function addSchedule(opts) {
   const cwd = process.cwd();
   const id = makeScheduleId(opts.platform, cwd);
   const replaced = getRegistered(id) !== void 0;
-  const logDir = path11.join(cwd, LOG_DIR_REL);
-  fs11.mkdirSync(logDir, { recursive: true });
-  const logFile = path11.join(logDir, `${opts.platform}.log`);
+  const logDir = path12.join(cwd, LOG_DIR_REL);
+  fs12.mkdirSync(logDir, { recursive: true });
+  const logFile = path12.join(logDir, `${opts.platform}.log`);
   const entry = {
     id,
     platform: opts.platform,
@@ -8779,15 +8911,15 @@ function removeSchedule(idOrPlatform, options) {
 function scheduleStatus() {
   const entries = listSchedules();
   return entries.map((entry) => {
-    const logExists = fs11.existsSync(entry.logFile);
-    const logSize = logExists ? fs11.statSync(entry.logFile).size : 0;
+    const logExists = fs12.existsSync(entry.logFile);
+    const logSize = logExists ? fs12.statSync(entry.logFile).size : 0;
     let logTail = [];
     let lastRunAt = null;
     if (logExists) {
       try {
-        lastRunAt = fs11.statSync(entry.logFile).mtime.toISOString();
+        lastRunAt = fs12.statSync(entry.logFile).mtime.toISOString();
         if (logSize > 0) {
-          const content = fs11.readFileSync(entry.logFile, "utf-8");
+          const content = fs12.readFileSync(entry.logFile, "utf-8");
           logTail = content.trim().split("\n").slice(-10);
         }
       } catch {
@@ -8795,8 +8927,8 @@ function scheduleStatus() {
     }
     let drift = "ok";
     if (!entry.cronInstalled) drift = "missing-cron";
-    else if (!fs11.existsSync(entry.nodeBin)) drift = "stale-node-bin";
-    else if (!fs11.existsSync(entry.cliBin)) drift = "stale-cli-bin";
+    else if (!fs12.existsSync(entry.nodeBin)) drift = "stale-node-bin";
+    else if (!fs12.existsSync(entry.cliBin)) drift = "stale-cli-bin";
     return { entry, logExists, logSize, logTail, lastRunAt, drift };
   });
 }
@@ -9069,11 +9201,11 @@ function isNoise(s) {
   if (/^-?\d+(\.\d+)?([eE][-+]?\d+)?$/.test(s)) return true;
   return false;
 }
-function recordSample(stats, path15, value, jsType, recordIndex, totalSamples) {
-  let s = stats.get(path15);
+function recordSample(stats, path16, value, jsType, recordIndex, totalSamples) {
+  let s = stats.get(path16);
   if (!s) {
     s = {
-      path: path15,
+      path: path16,
       total: totalSamples,
       recordIndices: /* @__PURE__ */ new Set(),
       lenSum: 0,
@@ -9082,7 +9214,7 @@ function recordSample(stats, path15, value, jsType, recordIndex, totalSamples) {
       primaryType: jsType,
       examples: []
     };
-    stats.set(path15, s);
+    stats.set(path16, s);
   }
   s.recordIndices.add(recordIndex);
   s.lenSum += value.length;
@@ -9091,28 +9223,28 @@ function recordSample(stats, path15, value, jsType, recordIndex, totalSamples) {
   if (s.primaryType !== jsType) s.primaryType = "mixed";
   if (s.examples.length < 3 && value.length < 200) s.examples.push(value);
 }
-function walkRecord(record, path15, stats, recordIndex, totalSamples) {
+function walkRecord(record, path16, stats, recordIndex, totalSamples) {
   if (record === null || record === void 0) return;
   if (typeof record === "string") {
     const trimmed = record.trim();
-    if (trimmed) recordSample(stats, path15, trimmed, "string", recordIndex, totalSamples);
+    if (trimmed) recordSample(stats, path16, trimmed, "string", recordIndex, totalSamples);
     return;
   }
   if (typeof record === "number" || typeof record === "boolean") {
     const str = String(record);
     const kind = typeof record === "number" ? "number" : "boolean";
-    if (str) recordSample(stats, path15, str, kind, recordIndex, totalSamples);
+    if (str) recordSample(stats, path16, str, kind, recordIndex, totalSamples);
     return;
   }
   if (Array.isArray(record)) {
-    const childPath = path15 ? `${path15}[]` : "[]";
+    const childPath = path16 ? `${path16}[]` : "[]";
     for (const item of record) walkRecord(item, childPath, stats, recordIndex, totalSamples);
     return;
   }
   if (typeof record === "object") {
     for (const [key, value] of Object.entries(record)) {
       if (key.startsWith("_")) continue;
-      const childPath = path15 ? `${path15}.${key}` : key;
+      const childPath = path16 ? `${path16}.${key}` : key;
       walkRecord(value, childPath, stats, recordIndex, totalSamples);
     }
   }
@@ -9443,17 +9575,85 @@ Run with --config to save:
   } else if (patch.connectionKey && !patch.connection) {
     delete profile.connection;
   }
+  const existingApproved = existing ? isShellApproved(existing) : false;
+  const mergedCommands = shellCommandsOf(profile);
+  const userSupplied = SHELL_FIELDS.every((f) => {
+    const value = mergedCommands[f];
+    if (value === void 0) return true;
+    if (patch[f] === value) return true;
+    return existingApproved && existing[f] === value;
+  });
   try {
     writeProfile(profile);
+    const needsApproval = Object.keys(mergedCommands).length > 0 && !userSupplied;
+    if (!needsApproval) approveShellCommands(profile);
     if (isAgentMode()) {
-      json({ status: "created", platform, model, profile });
+      json({
+        status: "created",
+        platform,
+        model,
+        profile,
+        ...needsApproval ? { shellApproval: "required", _hint: `Run: one sync approve ${platform} --models ${model}` } : {}
+      });
     } else {
       outro(`Sync profile saved for ${platform}/${model}`);
+      if (needsApproval) {
+        console.log(
+          `  ${pc11.yellow("!")} This profile runs shell commands you didn't supply here. Review them, then run ${pc11.bold(`one sync approve ${platform} --models ${model}`)}.`
+        );
+      }
     }
   } catch (err) {
     error(`Error saving profile: ${err instanceof Error ? err.message : String(err)}`);
   }
 }
+async function syncApproveCommand(platform, options) {
+  const models = options.models?.split(",").map((m) => m.trim()).filter(Boolean);
+  const profiles = listProfiles(platform).filter((pr) => !models || models.includes(pr.model));
+  if (profiles.length === 0) {
+    error(`No sync profiles found for ${platform}${models ? ` with models: ${models.join(", ")}` : ""}.`);
+  }
+  const pending = profiles.filter((pr) => !isShellApproved(pr));
+  if (pending.length === 0) {
+    if (isAgentMode()) {
+      json({ status: "approved", platform, approved: [], alreadyApproved: profiles.map((pr) => pr.model) });
+    } else {
+      outro(`Nothing to approve: ${platform} profiles run no unapproved shell commands.`);
+    }
+    return;
+  }
+  if (!isAgentMode()) {
+    for (const pr of pending) {
+      const lines = Object.entries(shellCommandsOf(pr)).map(([f, c]) => `${f}: ${c}`).join("\n");
+      note(lines, `${pr.platform}/${pr.model} runs these with sh -c`);
+    }
+  }
+  if (!options.yes) {
+    if (isAgentMode()) {
+      json({
+        status: "confirmation_required",
+        platform,
+        pending: pending.map((pr) => ({ model: pr.model, commands: shellCommandsOf(pr) })),
+        _hint: "Show these commands to the user. Re-run with --yes only after they approve them."
+      });
+      return;
+    }
+    const confirmed = await p6.confirm({
+      message: `Allow sync to run ${pending.length === 1 ? "this command set" : "these command sets"} in ${process.cwd()}?`,
+      initialValue: false
+    });
+    if (p6.isCancel(confirmed) || !confirmed) {
+      cancel("Not approved.");
+      return;
+    }
+  }
+  for (const pr of pending) approveShellCommands(pr);
+  if (isAgentMode()) {
+    json({ status: "approved", platform, approved: pending.map((pr) => pr.model) });
+  } else {
+    outro(`Approved shell commands for ${pending.map((pr) => `${platform}/${pr.model}`).join(", ")}. If they change, sync will ask again.`);
+  }
+}
 async function syncTestCommand(platformModel, options = {}) {
   const [platform, model] = platformModel.split("/");
   if (!platform || !model) {
@@ -9547,7 +9747,7 @@ function buildSearchablePreview(profile, samples) {
   const first = samples[0];
   const paths = getSearchablePaths(profile);
   if (paths) {
-    const perPathAgg = paths.map((path15) => ({ path: path15, hits: 0, total: samples.length, sample: "" }));
+    const perPathAgg = paths.map((path16) => ({ path: path16, hits: 0, total: samples.length, sample: "" }));
     for (const record of samples) {
       const { paths: perPath } = extractSearchableFromPaths(record, paths);
       perPath.forEach((p9, i) => {
@@ -9791,7 +9991,7 @@ async function maybeAutoMigrateLegacy(platform, models) {
       `  detected legacy .one/sync/data/${platform}.db (${dbSize}) \u2014 auto-migrating into memory before sync.
 `
     );
-    const { memMigrateCommand: memMigrateCommand3 } = await import("./migrate-RJ7F2LPT.js");
+    const { memMigrateCommand: memMigrateCommand3 } = await import("./migrate-E5QDJRM4.js");
     await memMigrateCommand3({ platform, yes: true });
     return;
   }
@@ -9800,7 +10000,7 @@ async function maybeAutoMigrateLegacy(platform, models) {
     initialValue: true
   });
   if (p6.isCancel(shouldMigrate) || !shouldMigrate) return;
-  const { memMigrateCommand: memMigrateCommand2 } = await import("./migrate-RJ7F2LPT.js");
+  const { memMigrateCommand: memMigrateCommand2 } = await import("./migrate-E5QDJRM4.js");
   await memMigrateCommand2({ platform, yes: true });
 }
 async function syncSuggestSearchableCommand(platformModel, options = {}) {
@@ -9966,8 +10166,14 @@ async function syncScheduleAddCommand(platform, options) {
       every: options.every,
       models: options.models?.split(",").map((m) => m.trim())
     });
+    const scheduledModels = entry.models;
+    const unapproved = listProfiles(platform).filter((pr) => !scheduledModels || scheduledModels.includes(pr.model)).filter((pr) => !isShellApproved(pr)).map((pr) => pr.model);
     if (isAgentMode()) {
-      json({ status: replaced ? "replaced" : "scheduled", ...entry });
+      json({
+        status: replaced ? "replaced" : "scheduled",
+        ...entry,
+        ...unapproved.length > 0 ? { unapprovedShellCommands: unapproved, _hint: `These models will fail until approved: one sync approve ${platform} --models ${unapproved.join(",")}` } : {}
+      });
       return;
     }
     const verb = replaced ? "Replaced existing schedule" : "Scheduled sync";
@@ -9975,6 +10181,11 @@ async function syncScheduleAddCommand(platform, options) {
       `${verb} ${pc11.bold(entry.id)} \u2014 every ${pc11.bold(entry.every)} (cron: ${pc11.dim(entry.cronExpr)})
 Logs: ${pc11.dim(entry.logFile)}`
     );
+    if (unapproved.length > 0) {
+      console.log(
+        `  ${pc11.yellow("!")} ${unapproved.map((m) => `${platform}/${m}`).join(", ")} run shell commands that aren't approved, so scheduled runs will skip ${unapproved.length === 1 ? "it" : "them"}. Run ${pc11.bold(`one sync approve ${platform} --models ${unapproved.join(",")}`)}.`
+      );
+    }
   } catch (err) {
     error(err instanceof Error ? err.message : String(err));
   }
@@ -10143,6 +10354,9 @@ function registerSyncSubcommands(sync) {
   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("approve <platform>").description("Approve the shell commands (transform, onInsert, onUpdate, onChange) in this project's sync profiles").option("--models <models>", "Only these models (comma-separated)").option("--yes", "Approve without the confirmation prompt").action(async (platform, options) => {
+    await syncApproveCommand(platform, options);
+  });
   sync.command("list [platform]").alias("ls").description("List all configured sync profiles and their status").action(async (platform) => {
     await syncListCommand(platform);
   });
@@ -10504,16 +10718,16 @@ function projectEmbeddingApiKey(cfg) {
 }
 function redactSecrets(cfg) {
   const copy = JSON.parse(JSON.stringify(cfg));
-  for (const path15 of SECRET_PATHS) {
-    const val = getPath(copy, path15);
+  for (const path16 of SECRET_PATHS) {
+    const val = getPath(copy, path16);
     if (typeof val === "string" && val.length > 0) {
-      setPath(copy, path15, `${val.slice(0, 6)}\u2026(redacted, use --show-secrets)`);
+      setPath(copy, path16, `${val.slice(0, 6)}\u2026(redacted, use --show-secrets)`);
     }
   }
   return copy;
 }
-function getPath(obj, path15) {
-  const parts = path15.split(".");
+function getPath(obj, path16) {
+  const parts = path16.split(".");
   let cur = obj;
   for (const part2 of parts) {
     if (cur == null || typeof cur !== "object") return void 0;
@@ -10521,8 +10735,8 @@ function getPath(obj, path15) {
   }
   return cur;
 }
-function setPath(obj, path15, value) {
-  const parts = path15.split(".");
+function setPath(obj, path16, value) {
+  const parts = path16.split(".");
   let cur = obj;
   for (let i = 0; i < parts.length - 1; i++) {
     const part2 = parts[i];
@@ -10532,8 +10746,8 @@ function setPath(obj, path15, value) {
   cur[parts[parts.length - 1]] = value;
   return obj;
 }
-function unsetPath(obj, path15) {
-  const parts = path15.split(".");
+function unsetPath(obj, path16) {
+  const parts = path16.split(".");
   let cur = obj;
   for (let i = 0; i < parts.length - 1; i++) {
     const part2 = parts[i];
@@ -10972,7 +11186,7 @@ ${pc13.dim(line)}`);
 }
 
 // src/commands/mem/export.ts
-import fs12 from "fs";
+import fs13 from "fs";
 import { once } from "events";
 async function writeLine(stream, line) {
   if (!stream.write(line)) {
@@ -10984,7 +11198,7 @@ async function memExportCommand(outfile) {
   const backend = await getBackend();
   const stats = await backend.stats();
   const toFile = !!outfile && outfile !== "-";
-  const stream = toFile ? fs12.createWriteStream(outfile, "utf-8") : process.stdout;
+  const stream = toFile ? fs13.createWriteStream(outfile, "utf-8") : process.stdout;
   const all = await listAllTypes(backend);
   const pageSize = 500;
   let written = 0;
@@ -11015,9 +11229,9 @@ async function memExportCommand(outfile) {
 }
 async function memImportCommand(file) {
   requireMemoryInit();
-  if (!fs12.existsSync(file)) error(`File not found: ${file}`);
+  if (!fs13.existsSync(file)) error(`File not found: ${file}`);
   const backend = await getBackend();
-  const raw = fs12.readFileSync(file, "utf-8");
+  const raw = fs13.readFileSync(file, "utf-8");
   const lines = raw.split("\n").filter((l) => l.trim().length > 0);
   let inserted = 0;
   let updated = 0;
@@ -12455,6 +12669,15 @@ Hooks fire after each page (not end-of-sync) for real-time processing. Each even
 
 Every record has a \`_synced_at\` timestamp so you can track when it was last pulled.
 
+### Approving shell commands
+
+\`transform\` and every hook except \`"log"\` run through \`sh -c\`. Profiles live in the project, so a cloned repo can ship them. \`sync run\` (and scheduled runs) refuse a profile's shell commands until they are approved for that project directory:
+
+- Commands you pass yourself in \`sync init --config\` are approved automatically.
+- Commands already in a profile on disk, e.g. from a cloned repo, need \`one sync approve <platform> [--models <m>]\`. It shows the exact commands and asks before approving. In agent mode it returns \`confirmation_required\` with the commands; show them to the user and pass \`--yes\` only once they agree.
+- The approval covers the exact commands. If they change, e.g. after a \`git pull\`, sync refuses them again until re-approved.
+- Approvals are stored in \`~/.one/sync/shell-approvals.json\`, never in the project. \`--dry-run\` stops before any command runs and needs no approval.
+
 ## Full Refresh (deletion detection)
 
 \`\`\`bash
@@ -12907,7 +13130,7 @@ function buildWorkflowIdeas(connections) {
 }
 
 // src/commands/logout.ts
-import fs13 from "fs";
+import fs14 from "fs";
 import * as p8 from "@clack/prompts";
 function formatWhoami(config2, apiKey, pc17) {
   const whoami = config2.whoami;
@@ -12942,12 +13165,12 @@ async function logoutCommand() {
     const globalPath = getGlobalConfigPath();
     const projectPath = getProjectConfigPath();
     let cleared = false;
-    if (fs13.existsSync(projectPath)) {
-      fs13.unlinkSync(projectPath);
+    if (fs14.existsSync(projectPath)) {
+      fs14.unlinkSync(projectPath);
       cleared = true;
     }
-    if (fs13.existsSync(globalPath)) {
-      fs13.unlinkSync(globalPath);
+    if (fs14.existsSync(globalPath)) {
+      fs14.unlinkSync(globalPath);
       cleared = true;
     }
     json({ status: cleared ? "logged_out" : "not_logged_in", message: cleared ? "Credentials cleared." : "No config found." });
@@ -13016,11 +13239,11 @@ async function logoutCommand() {
   }
   if (targetScope === "project" || targetScope === "both") {
     const projectPath = getProjectConfigPath();
-    if (fs13.existsSync(projectPath)) fs13.unlinkSync(projectPath);
+    if (fs14.existsSync(projectPath)) fs14.unlinkSync(projectPath);
   }
   if (targetScope === "global" || targetScope === "both") {
     const globalPath = getGlobalConfigPath();
-    if (fs13.existsSync(globalPath)) fs13.unlinkSync(globalPath);
+    if (fs14.existsSync(globalPath)) fs14.unlinkSync(globalPath);
   }
   p8.log.success("Credentials cleared.");
   p8.log.info("Your API key is still active. Manage keys at app.withone.ai/settings");
@@ -13028,10 +13251,10 @@ async function logoutCommand() {
 }
 
 // src/lib/project-skills.ts
-import crypto3 from "crypto";
-import fs14 from "fs";
+import crypto4 from "crypto";
+import fs15 from "fs";
 import os2 from "os";
-import path12 from "path";
+import path13 from "path";
 import zlib2 from "zlib";
 var OPTIONAL_SKILLS = [
   {
@@ -13063,27 +13286,27 @@ function findAgentTarget(id) {
   return SKILL_AGENT_TARGETS.find((a) => a.id === id.trim().toLowerCase());
 }
 function findProjectRoot(start) {
-  let dir = path12.resolve(start);
+  let dir = path13.resolve(start);
   for (; ; ) {
-    if (fs14.existsSync(path12.join(dir, "package.json")) || fs14.existsSync(path12.join(dir, ".git"))) return dir;
-    const parent = path12.dirname(dir);
+    if (fs15.existsSync(path13.join(dir, "package.json")) || fs15.existsSync(path13.join(dir, ".git"))) return dir;
+    const parent = path13.dirname(dir);
     if (parent === dir) return null;
     dir = parent;
   }
 }
 function findInstalledPackage(start, packageName) {
-  let dir = path12.resolve(start);
+  let dir = path13.resolve(start);
   for (; ; ) {
-    const pkgDir = path12.join(dir, "node_modules", ...packageName.split("/"));
-    const manifest = path12.join(pkgDir, "package.json");
-    if (fs14.existsSync(manifest)) {
+    const pkgDir = path13.join(dir, "node_modules", ...packageName.split("/"));
+    const manifest = path13.join(pkgDir, "package.json");
+    if (fs15.existsSync(manifest)) {
       try {
-        const { version: version2 } = JSON.parse(fs14.readFileSync(manifest, "utf-8"));
+        const { version: version2 } = JSON.parse(fs15.readFileSync(manifest, "utf-8"));
         if (version2) return { dir: pkgDir, version: version2 };
       } catch {
       }
     }
-    const parent = path12.dirname(dir);
+    const parent = path13.dirname(dir);
     if (parent === dir) return null;
     dir = parent;
   }
@@ -13097,8 +13320,8 @@ var SkillSourceError = class extends Error {
 function projectSkillSource(skill, projectDir) {
   const installed = findInstalledPackage(projectDir, skill.packageName);
   if (!installed) return null;
-  const dir = path12.join(installed.dir, ...skill.packagePath.split("/"));
-  if (!fs14.existsSync(path12.join(dir, "SKILL.md"))) {
+  const dir = path13.join(installed.dir, ...skill.packagePath.split("/"));
+  if (!fs15.existsSync(path13.join(dir, "SKILL.md"))) {
     throw new SkillSourceError(
       `${skill.packageName} ${installed.version} does not include the ${skill.title} skill. Upgrade it: npm install ${skill.packageName}@latest`,
       "skill-missing"
@@ -13141,11 +13364,11 @@ async function registrySkillSource(skill, fetchImpl = fetch) {
   if (!files.some((f) => f.path === "SKILL.md")) {
     throw new SkillSourceError(`${skill.packageName}@${version2} does not include the ${skill.title} skill.`, "not-in-package");
   }
-  const tmp = fs14.mkdtempSync(path12.join(os2.tmpdir(), "one-skill-"));
+  const tmp = fs15.mkdtempSync(path13.join(os2.tmpdir(), "one-skill-"));
   for (const file of files) {
-    const dest = path12.join(tmp, ...file.path.split("/"));
-    fs14.mkdirSync(path12.dirname(dest), { recursive: true });
-    fs14.writeFileSync(dest, file.data);
+    const dest = path13.join(tmp, ...file.path.split("/"));
+    fs15.mkdirSync(path13.dirname(dest), { recursive: true });
+    fs15.writeFileSync(dest, file.data);
   }
   return {
     kind: "registry",
@@ -13154,7 +13377,7 @@ async function registrySkillSource(skill, fetchImpl = fetch) {
     origin: tarball,
     cleanup: () => {
       try {
-        fs14.rmSync(tmp, { recursive: true, force: true });
+        fs15.rmSync(tmp, { recursive: true, force: true });
       } catch {
       }
     }
@@ -13166,7 +13389,7 @@ function matchesIntegrity(bytes, integrity) {
     if (dash < 0) return false;
     const algorithm = entry.slice(0, dash);
     if (!["sha512", "sha384", "sha256"].includes(algorithm)) return false;
-    return crypto3.createHash(algorithm).update(bytes).digest("base64") === entry.slice(dash + 1);
+    return crypto4.createHash(algorithm).update(bytes).digest("base64") === entry.slice(dash + 1);
   });
 }
 function readTarEntries(tar, prefix) {
@@ -13198,7 +13421,7 @@ function readTarEntries(tar, prefix) {
       if ((type === "0" || type === "\0") && full.startsWith(prefix)) {
         const rel = full.slice(prefix.length);
         const parts = rel.split("/");
-        if (rel && !path12.isAbsolute(rel) && !parts.includes("..") && !parts.includes("")) {
+        if (rel && !path13.isAbsolute(rel) && !parts.includes("..") && !parts.includes("")) {
           out.push({ path: rel, data: Buffer.from(body) });
         }
       }
@@ -13209,11 +13432,11 @@ function readTarEntries(tar, prefix) {
 }
 var SKILL_STAMP = ".one-skill.json";
 function canonicalSkillDir(skill, plan) {
-  return path12.join(plan.root, ...UNIVERSAL_PROJECT_DIR.split("/"), skill.dirName);
+  return path13.join(plan.root, ...UNIVERSAL_PROJECT_DIR.split("/"), skill.dirName);
 }
 function readStamp(dir) {
   try {
-    return JSON.parse(fs14.readFileSync(path12.join(dir, SKILL_STAMP), "utf-8"));
+    return JSON.parse(fs15.readFileSync(path13.join(dir, SKILL_STAMP), "utf-8"));
   } catch {
     return null;
   }
@@ -13223,9 +13446,9 @@ function resolveAgentFolders(plan) {
   const chosen = SKILL_AGENT_TARGETS.filter((agent) => {
     if (explicit) return plan.agents.includes(agent.id);
     if (plan.scope === "global") {
-      return fs14.existsSync(path12.join(plan.root, path12.dirname(agent.homeDir)));
+      return fs15.existsSync(path13.join(plan.root, path13.dirname(agent.homeDir)));
     }
-    return agent.projectMarker === null || fs14.existsSync(path12.join(plan.root, agent.projectMarker));
+    return agent.projectMarker === null || fs15.existsSync(path13.join(plan.root, agent.projectMarker));
   });
   const readers = [];
   const byDir = /* @__PURE__ */ new Map();
@@ -13240,34 +13463,34 @@ function resolveAgentFolders(plan) {
   return { readers, folders: [...byDir].map(([dir, agents]) => ({ dir, agents })) };
 }
 function copyDir(src, dest) {
-  fs14.mkdirSync(dest, { recursive: true });
-  for (const entry of fs14.readdirSync(src, { withFileTypes: true })) {
+  fs15.mkdirSync(dest, { recursive: true });
+  for (const entry of fs15.readdirSync(src, { withFileTypes: true })) {
     if (entry.name === SKILL_STAMP) continue;
-    const from = path12.join(src, entry.name);
-    const to = path12.join(dest, entry.name);
+    const from = path13.join(src, entry.name);
+    const to = path13.join(dest, entry.name);
     if (entry.isSymbolicLink()) continue;
     if (entry.isDirectory()) copyDir(from, to);
-    else if (entry.isFile()) fs14.copyFileSync(from, to);
+    else if (entry.isFile()) fs15.copyFileSync(from, to);
   }
 }
 function removePath(target) {
   try {
-    const stat = fs14.lstatSync(target);
-    if (stat.isSymbolicLink()) fs14.unlinkSync(target);
-    else fs14.rmSync(target, { recursive: true, force: true });
+    const stat = fs15.lstatSync(target);
+    if (stat.isSymbolicLink()) fs15.unlinkSync(target);
+    else fs15.rmSync(target, { recursive: true, force: true });
   } catch {
   }
 }
 function linkDir(target, linkPath) {
   removePath(linkPath);
-  fs14.mkdirSync(path12.dirname(linkPath), { recursive: true });
+  fs15.mkdirSync(path13.dirname(linkPath), { recursive: true });
   try {
-    fs14.symlinkSync(path12.relative(path12.dirname(linkPath), target), linkPath, "dir");
+    fs15.symlinkSync(path13.relative(path13.dirname(linkPath), target), linkPath, "dir");
     return "symlink";
   } catch {
   }
   try {
-    fs14.symlinkSync(target, linkPath, "junction");
+    fs15.symlinkSync(target, linkPath, "junction");
     return "junction";
   } catch {
   }
@@ -13285,15 +13508,15 @@ function stampLinkPath(skill, plan, rel) {
 }
 function assertInsideProject(plan, target) {
   if (plan.scope !== "project") return;
-  let dir = path12.dirname(target);
-  while (!fs14.existsSync(dir)) {
-    const parent = path12.dirname(dir);
+  let dir = path13.dirname(target);
+  while (!fs15.existsSync(dir)) {
+    const parent = path13.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
-  const realRoot = fs14.realpathSync(plan.root);
-  const rel = path12.relative(realRoot, fs14.realpathSync(dir));
-  if (rel.startsWith("..") || path12.isAbsolute(rel)) {
+  const realRoot = fs15.realpathSync(plan.root);
+  const rel = path13.relative(realRoot, fs15.realpathSync(dir));
+  if (rel.startsWith("..") || path13.isAbsolute(rel)) {
     throw new Error(`Refusing to change ${target}: a folder on that path leads outside the project (${plan.root}).`);
   }
 }
@@ -13328,20 +13551,20 @@ function installSkill(skill, source, plan, cliVersion2) {
     installedBy: `@withone/cli@${cliVersion2}`,
     installedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  fs14.writeFileSync(path12.join(canonical, SKILL_STAMP), JSON.stringify(stamp, null, 2) + "\n");
+  fs15.writeFileSync(path13.join(canonical, SKILL_STAMP), JSON.stringify(stamp, null, 2) + "\n");
   return { skill, version: source.version, source: source.kind, origin: source.origin, scope: plan.scope, root: plan.root, canonical, readers, links };
 }
 function removeSkill(skill, plan) {
   const canonical = canonicalSkillDir(skill, plan);
   const stamp = readStamp(canonical);
-  if (!stamp && !fs14.existsSync(path12.join(canonical, "SKILL.md"))) return { removed: false, paths: [] };
+  if (!stamp && !fs15.existsSync(path13.join(canonical, "SKILL.md"))) return { removed: false, paths: [] };
   const paths = [];
   assertInsideProject(plan, canonical);
   for (const link of stamp?.links ?? []) {
     const full = stampLinkPath(skill, plan, link.path);
     if (!full) continue;
     assertInsideProject(plan, full);
-    if (fs14.existsSync(full) || isDanglingLink(full)) {
+    if (fs15.existsSync(full) || isDanglingLink(full)) {
       removePath(full);
       paths.push(full);
     }
@@ -13354,18 +13577,18 @@ function toPosix(p9) {
   return p9.split("\\").join("/");
 }
 function fromStamp(root, rel) {
-  return path12.join(root, ...toPosix(rel).split("/"));
+  return path13.join(root, ...toPosix(rel).split("/"));
 }
 function isDanglingLink(p9) {
   try {
-    return fs14.lstatSync(p9).isSymbolicLink();
+    return fs15.lstatSync(p9).isSymbolicLink();
   } catch {
     return false;
   }
 }
 function installedSkill(skill, plan) {
   const canonical = canonicalSkillDir(skill, plan);
-  if (!fs14.existsSync(path12.join(canonical, "SKILL.md"))) return null;
+  if (!fs15.existsSync(path13.join(canonical, "SKILL.md"))) return null;
   const stamp = readStamp(canonical);
   return { scope: plan.scope, root: plan.root, canonical, version: stamp?.version ?? null, source: stamp?.source ?? null, links: stamp?.links ?? [] };
 }
@@ -13374,7 +13597,7 @@ function globalRoot() {
 }
 function refreshProjectSkills(cwd, cliVersion2) {
   const root = findProjectRoot(cwd);
-  if (!root || path12.resolve(root) === path12.resolve(homeDir())) return [];
+  if (!root || path13.resolve(root) === path13.resolve(homeDir())) return [];
   const results = [];
   for (const skill of OPTIONAL_SKILLS) {
     const canonical = canonicalSkillDir(skill, { scope: "project", root });
@@ -13397,7 +13620,7 @@ function refreshProjectSkills(cwd, cliVersion2) {
 }
 
 // src/commands/skills.ts
-import path13 from "path";
+import path14 from "path";
 import pc16 from "picocolors";
 function requireSkill(name) {
   const skill = findOptionalSkill(name);
@@ -13421,7 +13644,7 @@ function resolvePlan(options) {
   const agents = parseAgents(options.agents);
   if (options.global) return { scope: "global", root: globalRoot(), agents };
   const root = findProjectRoot(process.cwd());
-  if (!root || path13.resolve(root) === path13.resolve(homeDir())) {
+  if (!root || path14.resolve(root) === path14.resolve(homeDir())) {
     error("No project here: run this inside your app (a folder with package.json or .git), or pass --global.");
   }
   return { scope: "project", root, agents };
@@ -13437,7 +13660,7 @@ async function resolveSource(skill, plan) {
   }
 }
 function display(p9, root) {
-  const rel = path13.relative(root, p9);
+  const rel = path14.relative(root, p9);
   return rel && !rel.startsWith("..") ? rel : p9;
 }
 function report(command, result, packageInProject) {
@@ -13453,7 +13676,7 @@ function report(command, result, packageInProject) {
       root: result.root,
       installedTo: [
         { path: result.canonical, kind: "folder", agents: result.readers },
-        ...result.links.map((l) => ({ path: path13.join(result.root, ...l.path.split("/")), kind: l.kind, agents: l.agents }))
+        ...result.links.map((l) => ({ path: path14.join(result.root, ...l.path.split("/")), kind: l.kind, agents: l.agents }))
       ],
       next: nextSteps(result, packageInProject)
     });
@@ -13555,8 +13778,8 @@ async function skillsRemoveCommand(name, options) {
   for (const p9 of result.paths) console.log(`    ${pc16.dim(display(p9, plan.root))}`);
 }
 async function skillsListCommand() {
-  const projectRoot = findProjectRoot(process.cwd());
-  const inProject = projectRoot && path13.resolve(projectRoot) !== path13.resolve(homeDir()) ? projectRoot : null;
+  const projectRoot2 = findProjectRoot(process.cwd());
+  const inProject = projectRoot2 && path14.resolve(projectRoot2) !== path14.resolve(homeDir()) ? projectRoot2 : null;
   const optional = OPTIONAL_SKILLS.map((skill) => {
     const project = inProject ? installedSkill(skill, { scope: "project", root: inProject }) : null;
     const global = installedSkill(skill, { scope: "global", root: globalRoot() });
@@ -13838,8 +14061,8 @@ config.command("reset").description("Remove the project config for the current d
         return;
       }
     }
-    const fs16 = await import("fs");
-    fs16.unlinkSync(globalPath);
+    const fs17 = await import("fs");
+    fs17.unlinkSync(globalPath);
     if (isAgentMode()) {
       json({ deleted: true, scope: "global" });
     } else {
@@ -13856,15 +14079,15 @@ config.command("reset").description("Remove the project config for the current d
     }
     return;
   }
-  const fs15 = await import("fs");
-  const configContent = fs15.readFileSync(resolved.path, "utf-8");
-  fs15.unlinkSync(resolved.path);
+  const fs16 = await import("fs");
+  const configContent = fs16.readFileSync(resolved.path, "utf-8");
+  fs16.unlinkSync(resolved.path);
   const next = resolveConfig();
-  fs15.mkdirSync(path14.dirname(resolved.path), { recursive: true });
-  fs15.writeFileSync(resolved.path, configContent);
+  fs16.mkdirSync(path15.dirname(resolved.path), { recursive: true });
+  fs16.writeFileSync(resolved.path, configContent);
   let fallbackLabel;
   if (next.scope === "project") {
-    fallbackLabel = `parent project config (${path14.basename(next.projectRoot)})`;
+    fallbackLabel = `parent project config (${path15.basename(next.projectRoot)})`;
   } else if (next.scope === "global") {
     fallbackLabel = "global config";
   } else {
@@ -13873,7 +14096,7 @@ config.command("reset").description("Remove the project config for the current d
   if (!isAgentMode()) {
     const p9 = await import("@clack/prompts");
     const confirmed = await p9.confirm({
-      message: `Delete project config for ${path14.basename(resolved.projectRoot)}? Will fall back to ${fallbackLabel}.`,
+      message: `Delete project config for ${path15.basename(resolved.projectRoot)}? Will fall back to ${fallbackLabel}.`,
       initialValue: false
     });
     if (p9.isCancel(confirmed) || !confirmed) {
@@ -13881,9 +14104,9 @@ config.command("reset").description("Remove the project config for the current d
       return;
     }
   }
-  fs15.unlinkSync(resolved.path);
+  fs16.unlinkSync(resolved.path);
   try {
-    fs15.rmdirSync(path14.dirname(resolved.path));
+    fs16.rmdirSync(path15.dirname(resolved.path));
   } catch {
   }
   if (isAgentMode()) {