@withone/cli 1.32.1 → 1.34.0

package/README.md

@@ -98,7 +98,7 @@ one flow validate welcome-customer
 one flow execute welcome-customer -i email=jane@example.com
 ```
 
-Workflows live under `.one/flows/<key>/flow.json` with an optional `lib/` subfolder for `.mjs` code modules — create new flows in this folder layout. (The legacy single-file layout `.one/flows/<key>.flow.json` is deprecated but still loads for backward compatibility.) Flows support conditions, loops, while loops, parallel steps, transforms, sub-flows, pagination, bash steps, and external `.mjs` code modules. Run `one guide flows` for the full reference.
+Workflows live under `.one/flows/<key>/flow.json` with an optional `lib/` subfolder for `.mjs` code modules — create new flows in this folder layout. Flows can be organized into subdirectory groups: `.one/flows/<group>/<key>/flow.json`. Reference them as `group/key` or just the bare key if unique. (The legacy single-file layout `.one/flows/<key>.flow.json` is deprecated but still loads for backward compatibility.) Flows support conditions, loops, while loops, parallel steps, transforms, sub-flows, pagination, bash steps, and external `.mjs` code modules. Run `one guide flows` for the full reference.
 
 ## How it works
 
@@ -357,12 +357,15 @@ In agent mode (`--agent`), the JSON response includes the guide content and an `
 
 ### `one flow create [key]`
 
-Create a workflow from a JSON definition. New workflows are always saved to the folder layout at `.one/flows/<key>/flow.json` (with a `lib/` subfolder scaffolded for code modules). The legacy `.one/flows/<key>.flow.json` single-file layout is deprecated; existing legacy files continue to load and run unchanged for backward compatibility.
+Create a workflow from a JSON definition. New workflows are always saved to the folder layout at `.one/flows/<key>/flow.json` (with a `lib/` subfolder scaffolded for code modules). Use `group/key` to place flows in a subdirectory group (e.g. `.one/flows/research/company-research/flow.json`). The legacy `.one/flows/<key>.flow.json` single-file layout is deprecated; existing legacy files continue to load and run unchanged for backward compatibility.
 
 ```bash
 # From a --definition flag
 one flow create welcome-customer --definition '{"key":"welcome-customer","name":"Welcome","version":"1","inputs":{},"steps":[]}'
 
+# Create in a subdirectory group
+one flow create research/company-research --definition @flow.json
+
 # From stdin
 cat flow.json | one flow create
 

package/dist/{chunk-T7LTS2IE.js → chunk-HZP7NT4K.js}

@@ -1042,7 +1042,7 @@ async function executeSubflowStep(step, context, api, permissions, allowedAction
   if (flowStack.includes(resolvedKey)) {
     throw new Error(`Circular flow detected: ${[...flowStack, resolvedKey].join(" \u2192 ")}`);
   }
-  const { loadFlowWithMeta: loadFlowWithMeta2 } = await import("./flow-runner-6IFPWOS4.js");
+  const { loadFlowWithMeta: loadFlowWithMeta2 } = await import("./flow-runner-TNI7YWVY.js");
   const { flow: subFlow, rootDir: subRootDir } = loadFlowWithMeta2(resolvedKey);
   const subContext = await executeFlow(
     subFlow,
@@ -1847,7 +1847,18 @@ Workflows live in \`.one/flows/\` (relative to your current working directory \u
 - **Folder layout (REQUIRED for new flows)** \u2014 \`.one/flows/<key>/flow.json\`, with an optional \`lib/\` subfolder for JavaScript modules. This is like a skill: the folder groups the JSON spec with any JavaScript modules it needs, so the whole flow is shareable. **Always create new flows in this layout.**
 - **Single-file layout (DEPRECATED)** \u2014 \`.one/flows/<key>.flow.json\`. Still loads and runs for backward compatibility, but is deprecated. Do not create new flows in this layout. When editing an existing single-file flow, migrate it to the folder layout: move \`<key>.flow.json\` to \`<key>/flow.json\` and extract any non-trivial \`code.source\` blocks into \`<key>/lib/*.mjs\` modules.
 
-When resolving a flow by key, the CLI checks the folder layout first, then the deprecated legacy file. The \`loadFlow\` helper in agent integrations behaves the same.
+**Subdirectory groups** \u2014 Flows can be organized into subdirectories: \`.one/flows/<group>/<key>/flow.json\`. For example:
+\`\`\`
+.one/flows/
+  research/
+    company-research/flow.json
+    competitor-research/flow.json
+  deal-ops/
+    deal-log/flow.json
+\`\`\`
+Reference grouped flows with \`group/key\` (e.g. \`one flow execute research/company-research\`) or just the bare key if it's unique (e.g. \`one flow execute company-research\`). Create grouped flows with \`one flow create research/company-research --definition ...\`. \`flow list\` shows the group prefix.
+
+When resolving a flow by key, the CLI checks the folder layout first, then the deprecated legacy file, then scans group subdirectories. The \`loadFlow\` helper in agent integrations behaves the same.
 
 ## Before you execute a flow you did NOT author \u2014 READ THIS
 
@@ -1872,19 +1883,21 @@ A good description is one paragraph. If a flow's description doesn't tell you ho
 ## Commands
 
 \`\`\`bash
-one --agent flow create <key> --definition '<json>'   # Create (or --definition @file.json)
-one --agent flow create <key> --definition @flow.json  # Create from file
-one --agent flow list                                  # List
-one --agent flow validate <key>                        # Validate
-one --agent flow execute <key> -i name=value           # Execute
-one --agent flow execute <key> --dry-run --mock        # Test with mock data
-one --agent flow execute <key> --allow-bash            # Enable bash steps
-one --agent flow runs [flowKey]                        # List past runs
-one --agent flow resume <runId>                        # Resume failed run
-one --agent flow scaffold [template]                   # Generate a starter template
+one --agent flow create <key> --definition '<json>'              # Create (or --definition @file.json)
+one --agent flow create <key> --definition @flow.json            # Create from file
+one --agent flow create <group/key> --definition '<json>'        # Create in a subdirectory group
+one --agent flow list                                            # List (shows group prefixes)
+one --agent flow validate <key>                                  # Validate
+one --agent flow execute <key> -i name=value                     # Execute (bare key)
+one --agent flow execute <group/key> -i name=value               # Execute (namespaced key)
+one --agent flow execute <key> --dry-run --mock                  # Test with mock data
+one --agent flow execute <key> --allow-bash                      # Enable bash steps
+one --agent flow runs [flowKey]                                  # List past runs
+one --agent flow resume <runId>                                  # Resume failed run
+one --agent flow scaffold [template]                             # Generate a starter template
 \`\`\`
 
-You can also write the JSON file directly to \`.one/flows/<key>/flow.json\` \u2014 often easier than passing large JSON via --definition. (The legacy \`.one/flows/<key>.flow.json\` single-file location is deprecated; don't use it for new flows.)
+You can also write the JSON file directly to \`.one/flows/<key>/flow.json\` (or \`.one/flows/<group>/<key>/flow.json\` for grouped flows) \u2014 often easier than passing large JSON via --definition. (The legacy \`.one/flows/<key>.flow.json\` single-file location is deprecated; don't use it for new flows.)
 
 ## Code modules (flow \`lib/\` folder)
 
@@ -2501,13 +2514,31 @@ var FlowRunner = class _FlowRunner {
   }
 };
 function resolveFlowPath(keyOrPath) {
-  if (keyOrPath.includes("/") || keyOrPath.includes("\\") || keyOrPath.endsWith(".json")) {
+  if (keyOrPath.endsWith(".json")) {
+    return path2.resolve(keyOrPath);
+  }
+  if (keyOrPath.includes("\\")) {
     return path2.resolve(keyOrPath);
   }
+  if (keyOrPath.includes("/")) {
+    const nestedFolder = path2.resolve(FLOWS_DIR, keyOrPath, "flow.json");
+    if (fs2.existsSync(nestedFolder)) return nestedFolder;
+    const literal = path2.resolve(keyOrPath);
+    if (fs2.existsSync(literal)) return literal;
+    return nestedFolder;
+  }
   const folderPath = path2.resolve(FLOWS_DIR, keyOrPath, "flow.json");
-  const legacyPath = path2.resolve(FLOWS_DIR, `${keyOrPath}.flow.json`);
   if (fs2.existsSync(folderPath)) return folderPath;
+  const legacyPath = path2.resolve(FLOWS_DIR, `${keyOrPath}.flow.json`);
   if (fs2.existsSync(legacyPath)) return legacyPath;
+  const flowsDir = path2.resolve(FLOWS_DIR);
+  if (fs2.existsSync(flowsDir)) {
+    for (const entry of fs2.readdirSync(flowsDir, { withFileTypes: true })) {
+      if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
+      const nested = path2.join(flowsDir, entry.name, keyOrPath, "flow.json");
+      if (fs2.existsSync(nested)) return nested;
+    }
+  }
   return folderPath;
 }
 function getFlowRootDir(flowFilePath) {
@@ -2572,12 +2603,13 @@ function listFlows() {
   if (!fs2.existsSync(flowsDir)) return [];
   const flows = [];
   const seenKeys = /* @__PURE__ */ new Set();
-  const readFlowFile = (filePath) => {
+  const readFlowFile = (filePath, group) => {
     try {
       const content = fs2.readFileSync(filePath, "utf-8");
       const flow = JSON.parse(content);
-      if (seenKeys.has(flow.key)) return;
-      seenKeys.add(flow.key);
+      const nsKey = group ? `${group}/${flow.key}` : flow.key;
+      if (seenKeys.has(nsKey)) return;
+      seenKeys.add(nsKey);
       flows.push({
         key: flow.key,
         name: flow.name,
@@ -2586,6 +2618,7 @@ function listFlows() {
         stepCount: flow.steps.length,
         path: filePath,
         layout: path2.basename(filePath) === "flow.json" ? "folder" : "legacy",
+        group,
         stepTypes: collectStepTypes(flow),
         requiresBash: flowRequiresBash(flow),
         usesCodeModules: flowUsesCodeModules(flow),
@@ -2594,26 +2627,44 @@ function listFlows() {
     } catch {
     }
   };
-  for (const entry of fs2.readdirSync(flowsDir, { withFileTypes: true })) {
-    if (entry.name.startsWith(".")) continue;
-    const full = path2.join(flowsDir, entry.name);
-    if (entry.isDirectory()) {
-      const flowJson = path2.join(full, "flow.json");
-      if (fs2.existsSync(flowJson)) readFlowFile(flowJson);
-    } else if (entry.isFile() && entry.name.endsWith(".flow.json")) {
-      readFlowFile(full);
+  const scanDir = (dir, group) => {
+    for (const entry of fs2.readdirSync(dir, { withFileTypes: true })) {
+      if (entry.name.startsWith(".")) continue;
+      const full = path2.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        const flowJson = path2.join(full, "flow.json");
+        if (fs2.existsSync(flowJson)) {
+          readFlowFile(flowJson, group);
+        } else {
+          if (!group) {
+            scanDir(full, entry.name);
+          }
+        }
+      } else if (entry.isFile() && entry.name.endsWith(".flow.json")) {
+        readFlowFile(full, group);
+      }
     }
-  }
+  };
+  scanDir(flowsDir);
   return flows;
 }
-function saveFlow(flow, outputPath) {
+function saveFlow(flow, outputPath, group) {
   let flowPath;
   if (outputPath) {
     flowPath = path2.resolve(outputPath);
   } else {
-    const legacyPath = path2.resolve(FLOWS_DIR, `${flow.key}.flow.json`);
-    const folderPath = path2.resolve(FLOWS_DIR, flow.key, "flow.json");
-    if (fs2.existsSync(legacyPath) && !fs2.existsSync(folderPath)) {
+    let bareKey = flow.key;
+    let resolvedGroup = group;
+    if (flow.key.includes("/")) {
+      const parts = flow.key.split("/");
+      bareKey = parts.pop();
+      resolvedGroup = resolvedGroup || parts.join("/");
+      flow.key = bareKey;
+    }
+    const basePath = resolvedGroup ? path2.resolve(FLOWS_DIR, resolvedGroup, bareKey) : path2.resolve(FLOWS_DIR, bareKey);
+    const legacyPath = path2.resolve(FLOWS_DIR, `${bareKey}.flow.json`);
+    const folderPath = path2.join(basePath, "flow.json");
+    if (!resolvedGroup && fs2.existsSync(legacyPath) && !fs2.existsSync(folderPath)) {
       flowPath = legacyPath;
     } else {
       flowPath = folderPath;

package/dist/{flow-runner-6IFPWOS4.js → flow-runner-TNI7YWVY.js}

@@ -11,7 +11,7 @@ import {
   saveFlow,
   summarizeFlowInputs,
   walkSteps
-} from "./chunk-T7LTS2IE.js";
+} from "./chunk-HZP7NT4K.js";
 export {
   FlowRunner,
   collectStepTypes,

package/dist/index.js

@@ -19,10 +19,11 @@ import {
   resolveFlowPath,
   saveFlow,
   validateActionInput
-} from "./chunk-T7LTS2IE.js";
+} from "./chunk-HZP7NT4K.js";
 
 // src/index.ts
 import { createRequire as createRequire2 } from "module";
+import path16 from "path";
 import { Command } from "commander";
 
 // src/commands/init.ts
@@ -73,6 +74,19 @@ function resolveConfig() {
       return { config: config2, scope: "project", path: projectPath, projectRoot, projectSlug };
     }
   }
+  const root = path.parse(process.cwd()).root;
+  let dir = path.resolve(process.cwd());
+  while (dir !== root) {
+    dir = path.dirname(dir);
+    const slug = getProjectSlug(dir);
+    const configPath = path.join(PROJECTS_DIR, slug, "config.json");
+    if (fs.existsSync(configPath)) {
+      const config2 = readConfigFile(configPath);
+      if (config2) {
+        return { config: config2, scope: "project", path: configPath, projectRoot: dir, projectSlug: slug };
+      }
+    }
+  }
   if (fs.existsSync(CONFIG_FILE)) {
     const config2 = readConfigFile(CONFIG_FILE);
     if (config2) {
@@ -2882,32 +2896,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 path16 = `${pathPrefix}[${i}]`;
+    const path17 = `${pathPrefix}[${i}]`;
     if (!step || typeof step !== "object" || Array.isArray(step)) {
-      errors.push({ path: path16, message: "Step must be an object" });
+      errors.push({ path: path17, message: "Step must be an object" });
       continue;
     }
     const s = step;
     if (!s.id || typeof s.id !== "string") {
-      errors.push({ path: `${path16}.id`, message: 'Step must have a string "id"' });
+      errors.push({ path: `${path17}.id`, message: 'Step must have a string "id"' });
     }
     if (!s.name || typeof s.name !== "string") {
-      errors.push({ path: `${path16}.name`, message: 'Step must have a string "name"' });
+      errors.push({ path: `${path17}.name`, message: 'Step must have a string "name"' });
     }
     if (!s.type || !validTypes.includes(s.type)) {
-      errors.push({ path: `${path16}.type`, message: `Step type must be one of: ${validTypes.join(", ")}` });
+      errors.push({ path: `${path17}.type`, message: `Step type must be one of: ${validTypes.join(", ")}` });
       continue;
     }
     if (s.requires !== void 0) {
       if (!Array.isArray(s.requires)) {
-        errors.push({ path: `${path16}.requires`, message: '"requires" must be an array of selector strings (e.g. ["$.steps.foo.output.bar"])' });
+        errors.push({ path: `${path17}.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: `${path16}.requires[${r}]`, message: '"requires" entry must be a selector string' });
+            errors.push({ path: `${path17}.requires[${r}]`, message: '"requires" entry must be a selector string' });
           } else if (!sel.startsWith("$.")) {
-            errors.push({ path: `${path16}.requires[${r}]`, message: `"requires" entry "${sel}" must be a selector starting with "$." (e.g. "$.steps.foo.output.bar")` });
+            errors.push({ path: `${path17}.requires[${r}]`, message: `"requires" entry "${sel}" must be a selector starting with "$." (e.g. "$.steps.foo.output.bar")` });
           }
         }
       }
@@ -2915,7 +2929,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: `${path16}.onError.strategy`, message: `Error strategy must be one of: ${FLOW_SCHEMA.errorStrategies.join(", ")}` });
+        errors.push({ path: `${path17}.onError.strategy`, message: `Error strategy must be one of: ${FLOW_SCHEMA.errorStrategies.join(", ")}` });
       }
     }
     const descriptor = getStepTypeDescriptor(s.type);
@@ -2925,14 +2939,14 @@ function validateStepsArray(steps, pathPrefix, errors) {
     if (!configObj || typeof configObj !== "object") {
       const hint = detectFlatConfigHint(s, descriptor);
       errors.push({
-        path: `${path16}.${configKey}`,
+        path: `${path17}.${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 = `${path16}.${configKey}.${fieldName}`;
+      const fieldPath = `${path17}.${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}"` });
@@ -2968,24 +2982,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: `${path16}.${configKey}`, message: 'Code step must define either "source" (inline JS) or "module" (path to .mjs file)' });
+        errors.push({ path: `${path17}.${configKey}`, message: 'Code step must define either "source" (inline JS) or "module" (path to .mjs file)' });
       } else if (hasSource && hasModule) {
-        errors.push({ path: `${path16}.${configKey}`, message: 'Code step cannot define both "source" and "module" \u2014 pick one' });
+        errors.push({ path: `${path17}.${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: `${path16}.${configKey}.module`, message: "Code module path must be relative to the flow folder (no absolute paths)" });
+          errors.push({ path: `${path17}.${configKey}.module`, message: "Code module path must be relative to the flow folder (no absolute paths)" });
         } else if (m.split(/[\\/]/).includes("..")) {
-          errors.push({ path: `${path16}.${configKey}.module`, message: 'Code module path must not escape the flow folder ("..")' });
+          errors.push({ path: `${path17}.${configKey}.module`, message: 'Code module path must not escape the flow folder ("..")' });
         } else if (!m.endsWith(".mjs")) {
-          errors.push({ path: `${path16}.${configKey}.module`, message: "Code module must be a .mjs file" });
+          errors.push({ path: `${path17}.${configKey}.module`, message: "Code module must be a .mjs file" });
         }
       }
       if (hasSource) {
         const syntaxError = checkCodeSourceSyntax(config2.source);
         if (syntaxError) {
-          errors.push({ path: `${path16}.${configKey}.source`, message: `Syntax error in code step: ${syntaxError}` });
+          errors.push({ path: `${path17}.${configKey}.source`, message: `Syntax error in code step: ${syntaxError}` });
         }
       }
     }
@@ -3020,16 +3034,16 @@ function validateStepIds(flow2) {
   function collectIds(steps, pathPrefix) {
     for (let i = 0; i < steps.length; i++) {
       const step = steps[i];
-      const path16 = `${pathPrefix}[${i}]`;
+      const path17 = `${pathPrefix}[${i}]`;
       if (seen.has(step.id)) {
-        errors.push({ path: `${path16}.id`, message: `Duplicate step ID: "${step.id}"` });
+        errors.push({ path: `${path17}.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], `${path16}.${configKey}.${fieldName}`);
+          collectIds(config2[fieldName], `${path17}.${configKey}.${fieldName}`);
         }
       }
     }
@@ -3077,7 +3091,7 @@ function validateSelectorReferences(flow2) {
     }
     return selectors;
   }
-  function checkSelectors(selectors, path16, precedingStepIds) {
+  function checkSelectors(selectors, path17, precedingStepIds) {
     for (const selector of selectors) {
       const parts = selector.split(".");
       if (parts.length < 3) continue;
@@ -3085,15 +3099,15 @@ function validateSelectorReferences(flow2) {
       if (root === "input") {
         const inputName = parts[2];
         if (!inputNames.has(inputName)) {
-          errors.push({ path: path16, message: `Selector "${selector}" references undefined input "${inputName}"` });
+          errors.push({ path: path17, 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: path16, message: `Selector "${selector}" references undefined step "${stepId}"` });
+          errors.push({ path: path17, message: `Selector "${selector}" references undefined step "${stepId}"` });
         } else if (precedingStepIds && !precedingStepIds.has(stepId)) {
           errors.push({
-            path: path16,
+            path: path17,
             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.`
           });
         }
@@ -3101,20 +3115,20 @@ function validateSelectorReferences(flow2) {
     }
   }
   const EXPRESSION_FIELDS = /* @__PURE__ */ new Set(["condition.expression", "while.condition"]);
-  function checkOperatorsInSelectorField(value, path16) {
+  function checkOperatorsInSelectorField(value, path17) {
     if (typeof value === "string" && value.startsWith("$.")) {
       if (value.includes("||")) {
-        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.` });
+        errors.push({ path: path17, 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: 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.` });
+        errors.push({ path: path17, 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, `${path16}.${k}`);
+        checkOperatorsInSelectorField(v, `${path17}.${k}`);
       }
     } else if (Array.isArray(value)) {
       for (let i = 0; i < value.length; i++) {
-        checkOperatorsInSelectorField(value[i], `${path16}[${i}]`);
+        checkOperatorsInSelectorField(value[i], `${path17}[${i}]`);
       }
     }
   }
@@ -3182,10 +3196,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, path16) {
+function walkOutputSchema(schema, path17) {
   let current = schema;
-  for (let i = 0; i < path16.length; i++) {
-    const seg = path16[i];
+  for (let i = 0; i < path17.length; i++) {
+    const seg = path17[i];
     if (typeof current === "string") {
       return current === "unknown" || current === "object" || current === "array" ? "opaque" : "opaque";
     }
@@ -3449,8 +3463,15 @@ async function flowCreateCommand(key, options) {
   } else {
     error("Interactive workflow creation not yet supported. Use --definition <json> or pipe JSON via stdin.");
   }
+  let group;
   if (key) {
-    flow2.key = key;
+    if (key.includes("/")) {
+      const parts = key.split("/");
+      flow2.key = parts.pop();
+      group = parts.join("/");
+    } else {
+      flow2.key = key;
+    }
   }
   const errors = validateFlow(flow2);
   if (errors.length > 0) {
@@ -3461,7 +3482,7 @@ async function flowCreateCommand(key, options) {
     error(`Validation failed:
 ${errors.map((e) => `  ${e.path}: ${e.message}`).join("\n")}`);
   }
-  const flowPath = saveFlow(flow2, options.output);
+  const flowPath = saveFlow(flow2, options.output, group);
   if (isAgentMode()) {
     json({ created: true, key: flow2.key, path: flowPath });
     return;
@@ -3625,7 +3646,7 @@ async function flowListCommand() {
       { key: "flags", label: "Requires" }
     ],
     flows.map((f) => ({
-      key: f.key,
+      key: f.group ? `${f.group}/${f.key}` : f.key,
       name: f.name,
       layout: f.layout,
       inputCount: String(f.inputCount),
@@ -4954,8 +4975,8 @@ 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(".");
+  return template.replace(/\{?\{(\w+(?:\.\w+)*)\}\}?/g, (_, path17) => {
+    const parts = path17.split(".");
     let value = record;
     for (const part of parts) {
       if (typeof value !== "object" || value === null) return "";
@@ -4983,8 +5004,8 @@ function deepMerge(target, source) {
   }
   return result;
 }
-function getByDotPath2(obj, path16) {
-  const parts = path16.split(".");
+function getByDotPath2(obj, path17) {
+  const parts = path17.split(".");
   let current = obj;
   for (const part of parts) {
     if (current === null || current === void 0 || typeof current !== "object") return void 0;
@@ -4993,8 +5014,8 @@ function getByDotPath2(obj, path16) {
   return current;
 }
 function stripExcludedFields(obj, paths) {
-  for (const path16 of paths) {
-    stripOnePath(obj, path16.replace(/\[\]/g, ".*").split("."));
+  for (const path17 of paths) {
+    stripOnePath(obj, path17.replace(/\[\]/g, ".*").split("."));
   }
 }
 function stripOnePath(obj, parts) {
@@ -5300,8 +5321,8 @@ function sleep2(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 function stripFields(record, paths) {
-  for (const path16 of paths) {
-    stripOnePath2(record, path16.split("."));
+  for (const path17 of paths) {
+    stripOnePath2(record, path17.split("."));
   }
 }
 function stripOnePath2(obj, parts) {
@@ -7706,7 +7727,7 @@ one --agent flow list                                 # List all workflows
 \`\`\`
 
 **Key concepts:**
-- Workflows live at \`.one/flows/<key>/flow.json\` (folder layout \u2014 REQUIRED for new flows). The legacy \`.one/flows/<key>.flow.json\` single-file layout is DEPRECATED but still loads for backward compatibility
+- Workflows live at \`.one/flows/<key>/flow.json\` (folder layout \u2014 REQUIRED for new flows). Flows can be organized into subdirectory groups: \`.one/flows/<group>/<key>/flow.json\`. Reference them as \`group/key\` or just the bare key. The legacy \`.one/flows/<key>.flow.json\` single-file layout is DEPRECATED but still loads for backward compatibility
 - Code steps can reference an external \`.mjs\` module under the flow's \`lib/\` folder (stdin JSON in, stdout JSON out) \u2014 keeps JS out of JSON strings and makes flows shareable
 - 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\`
@@ -8683,8 +8704,8 @@ program.name("one").option("--agent", "Machine-readable JSON output (no colors,
 
   Workflows (multi-step):
     one flow list                         List saved workflows
-    one flow create [key]                 Create a workflow from JSON
-    one flow execute <key>                Execute a workflow
+    one flow create [key]                 Create a workflow from JSON (key can be group/key)
+    one flow execute <key>                Execute a workflow (key can be group/key)
     one flow validate <key>               Validate a flow
 
   Data Sync (run "one sync install" first, then "one guide sync" for full reference):
@@ -8828,6 +8849,83 @@ configSkills.command("status").description("Show installed skill version and whe
   console.log(`  current:   ${status.currentVersion}`);
   console.log(`  path:      ${status.canonicalPath}`);
 });
+config.command("reset").description("Remove the project config for the current directory (falls back to global)").option("--global", "Remove the global config instead").action(async (opts) => {
+  const resolved = resolveConfig();
+  if (opts.global) {
+    const globalPath = getGlobalConfigPath();
+    if (!globalConfigExists()) {
+      if (isAgentMode()) {
+        json({ deleted: false, reason: "No global config found" });
+      } else {
+        console.log("No global config found.");
+      }
+      return;
+    }
+    if (!isAgentMode()) {
+      const p8 = await import("@clack/prompts");
+      const confirmed = await p8.confirm({
+        message: "Delete the global config? This removes your API key for all projects without a project config.",
+        initialValue: false
+      });
+      if (p8.isCancel(confirmed) || !confirmed) {
+        console.log("Cancelled.");
+        return;
+      }
+    }
+    const fs17 = await import("fs");
+    fs17.unlinkSync(globalPath);
+    if (isAgentMode()) {
+      json({ deleted: true, scope: "global" });
+    } else {
+      console.log("Global config removed.");
+    }
+    return;
+  }
+  if (resolved.scope !== "project") {
+    if (isAgentMode()) {
+      json({ deleted: false, reason: "No project config found for this directory" });
+    } else {
+      console.log("No project config found for this directory.");
+      console.log(`Currently using: ${resolved.scope ?? "none"}`);
+    }
+    return;
+  }
+  const fs16 = await import("fs");
+  const configContent = fs16.readFileSync(resolved.path, "utf-8");
+  fs16.unlinkSync(resolved.path);
+  const next = resolveConfig();
+  fs16.mkdirSync(path16.dirname(resolved.path), { recursive: true });
+  fs16.writeFileSync(resolved.path, configContent);
+  let fallbackLabel;
+  if (next.scope === "project") {
+    fallbackLabel = `parent project config (${path16.basename(next.projectRoot)})`;
+  } else if (next.scope === "global") {
+    fallbackLabel = "global config";
+  } else {
+    fallbackLabel = "no config";
+  }
+  if (!isAgentMode()) {
+    const p8 = await import("@clack/prompts");
+    const confirmed = await p8.confirm({
+      message: `Delete project config for ${path16.basename(resolved.projectRoot)}? Will fall back to ${fallbackLabel}.`,
+      initialValue: false
+    });
+    if (p8.isCancel(confirmed) || !confirmed) {
+      console.log("Cancelled.");
+      return;
+    }
+  }
+  fs16.unlinkSync(resolved.path);
+  try {
+    fs16.rmdirSync(path16.dirname(resolved.path));
+  } catch {
+  }
+  if (isAgentMode()) {
+    json({ deleted: true, scope: "project", projectRoot: resolved.projectRoot, fallback: next.scope });
+  } else {
+    console.log(`Project config removed. Now using ${fallbackLabel}.`);
+  }
+});
 var connection = program.command("connection").description("Manage connections");
 connection.command("add [platform]").alias("a").description("Add a new connection").action(async (platform) => {
   await connectionAddCommand(platform);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@withone/cli",
-  "version": "1.32.1",
+  "version": "1.34.0",
   "description": "CLI for managing One",
   "type": "module",
   "files": [