devflow-kit 3.5.0 → 3.7.0

package/src/assets/scripts/resolve-settings.cjs

@@ -2,8 +2,8 @@
 // src/assets/scripts/resolve-settings.cjs
 //
 // Resolves the per-repository SETTINGS a prompt or the CLI acts on — tracker,
-// review publication, compliance lens and the three feature switches — from
-// LOCAL layers, and prints them on ONE closed-vocabulary line. Installed as a
+// review publication, compliance lens, the three feature switches and the gate
+// level — from LOCAL layers, and prints them on ONE closed-vocabulary line. Installed as a
 // top-level sibling of resolve-evidence-policy.cjs under ~/.devflow/scripts/,
 // sharing its parser (lib/project-config.cjs).
 //
@@ -14,15 +14,21 @@
 //   default   refs/remotes/origin/<D>:.devflow/project.json
 //                                               the default branch's tracking copy —
 //                                               its compliance ids only (D-LENS-UNION)
-//   personal  <toplevel>/.devflow/config.json   untracked, narrow-only — a copy git
-//                                               tracks is ignored (D-PERSONAL-UNTRACKED)
-//   machine   ~/.devflow/manifest.json          the machine-wide install
+//   personal  <toplevel>/.devflow/config.json   untracked — a copy git tracks is
+//                                               ignored (D-PERSONAL-UNTRACKED). It
+//                                               only narrows the feature switches;
+//                                               its `gateLevel` may raise or lower
+//   machine   ~/.devflow/manifest.json          the machine-wide install, and its
+//                                               `features.gateLevel` default
 //
 // D-SETTINGS-LOCAL-ONLY: local git subprocesses only, and never gh, never the
 // network, never a git command that refreshes the index. At most four, in order:
 //   git rev-parse --show-toplevel                         always
-//   git -c core.fsmonitor=false ls-files --error-unmatch -- .devflow/config.json
-//                                                         only when config.json exists
+//   git --no-literal-pathspecs -c core.fsmonitor=false ls-files -z -- <PERSONAL_TRACKING_PATHSPECS>
+//                                                         only when config.json exists;
+//                                                         ONE call answers every layout
+//                                                         in which git tracks the path
+//                                                         the personal file is opened at
 //   git symbolic-ref --quiet refs/remotes/origin/HEAD     in a repository
 //   git cat-file blob refs/remotes/origin/<D>:.devflow/project.json
 //                                                         only when origin/HEAD names D
@@ -37,11 +43,20 @@
 // for more than `auto`. The tracker (provider, site, key) is taken as the
 // branch states it. It WRITES NOTHING: each layer it folds is changed only by its owner.
 //
+// GATE_LEVEL is a level, not a switch, so narrow-only does not apply to it: the
+// personal `gateLevel` wins over the machine's `features.gateLevel`, which wins
+// over `standard`, and either may raise or lower the level. A present value that
+// is not full, standard or lean is malformed. That field alone reads `full`, the
+// other fields read as if the key were absent, and stderr names the layer (never
+// the value). A malformed personal value never falls through to the machine
+// value. The level comes from these two keys only — never from a task, a diff or
+// project.json.
+//
 // stdout is exactly one line plus "\n", or empty (D-SETTINGS-LINE):
 //   TRACKER=<github|jira|linear> TRACKER_SOURCE=<project|personal|machine|default>
 //   TRACKER_WARN=<none|mismatch|invalid> SITE=<url|none> KEY=<KEY|none>
 //   REVIEW_PUBLICATION=<off|auto|full> COMPLIANCE=<off|generic|id,…>
-//   MEMORY=<on|off> LEARNING=<on|off> KNOWLEDGE=<on|off>
+//   MEMORY=<on|off> LEARNING=<on|off> KNOWLEDGE=<on|off> GATE_LEVEL=<full|standard|lean>
 // (one line on stdout; wrapped here for reading). Every value is a closed token
 // or a SITE/KEY that passed its shape gate, so no other byte of a config file can
 // reach stdout. Whole-file rule: a project.json or config.json that EXISTS but
@@ -80,6 +95,7 @@ const projectConfig = require('./lib/project-config.cjs');
 
 const {
   PUBLICATIONS,
+  GATE_LEVELS,
   TRACKER_PROVIDER_IDS,
   COMPLIANCE_IDS,
   FEATURE_SWITCHES,
@@ -96,6 +112,8 @@ const {
 /** @typedef {'project' | 'personal' | 'machine' | 'default'} TrackerSource */
 /** @typedef {'none' | 'mismatch' | 'invalid'} TrackerWarn */
 /** @typedef {'off' | 'auto' | 'full'} Publication */
+/** @typedef {'full' | 'standard' | 'lean'} GateLevel */
+/** @typedef {'personal' | 'machine' | 'default'} GateLevelSource */
 /** @typedef {'memory' | 'learning' | 'knowledge'} FeatureSwitch */
 /** @typedef {'machine' | 'project' | 'personal'} SwitchSource */
 
@@ -144,6 +162,9 @@ const EXIT_CODES = Object.freeze({
  * with no other lens anywhere is exactly SETTINGS_FAIL_CLOSED_LINE, and an
  * unreadable machine manifest reads as no lens. Individually malformed keys
  * inside a readable object keep their per-key readings (AC-26).
+ *
+ * GATE_LEVEL is the last field, a closed group of the three level words: nothing
+ * broader than `full|standard|lean` can follow KNOWLEDGE.
  */
 const SETTINGS_LINE_RE = new RegExp(
   '^TRACKER=(?<tracker>' + TRACKER_PROVIDER_IDS.join('|') + ')'
@@ -154,7 +175,8 @@ const SETTINGS_LINE_RE = new RegExp(
   + ' REVIEW_PUBLICATION=(?<publication>' + PUBLICATIONS.join('|') + ')'
   + ' COMPLIANCE=(?<compliance>off|generic|(?:' + COMPLIANCE_IDS.join('|') + ')(?:,(?:'
   + COMPLIANCE_IDS.join('|') + ')){0,' + String(COMPLIANCE_IDS.length - 1) + '})'
-  + ' MEMORY=(?<memory>on|off) LEARNING=(?<learning>on|off) KNOWLEDGE=(?<knowledge>on|off)$',
+  + ' MEMORY=(?<memory>on|off) LEARNING=(?<learning>on|off) KNOWLEDGE=(?<knowledge>on|off)'
+  + ' GATE_LEVEL=(?<gateLevel>' + GATE_LEVELS.join('|') + ')$',
 );
 
 /**
@@ -169,14 +191,20 @@ const SETTINGS_LINE_RE = new RegExp(
  *   MEMORY/LEARNING=on       the machine switch is the one that turns them off;
  *                            hooks never consume this line (their gate folds an
  *                            unreadable file as narrowing nothing)
+ *   GATE_LEVEL=full          the most checking applies: a resolver that cannot read
+ *                            its inputs never lowers the level
  */
 const SETTINGS_FAIL_CLOSED_LINE =
   'TRACKER=github TRACKER_SOURCE=default TRACKER_WARN=invalid SITE=none KEY=none '
-  + 'REVIEW_PUBLICATION=off COMPLIANCE=generic MEMORY=on LEARNING=on KNOWLEDGE=off';
+  + 'REVIEW_PUBLICATION=off COMPLIANCE=generic MEMORY=on LEARNING=on KNOWLEDGE=off GATE_LEVEL=full';
 
 /** Bound on each local git call. */
 const GIT_TIMEOUT_MS = 5000;
-/** rev-parse, ls-files and symbolic-ref print one short line. */
+/**
+ * rev-parse and symbolic-ref print one short line. The tracking check's ls-files
+ * prints nothing, or the few index entries its two pathspecs name; a listing past
+ * this bound overflows (ENOBUFS), which reads as unanswered and fails closed.
+ */
 const LINE_MAX_BUFFER = 4096;
 /**
  * The tracking-copy read: one byte past the parser's bound, so an oversize blob
@@ -187,6 +215,39 @@ const BLOB_MAX_BUFFER = MAX_CONFIG_BYTES + 1;
 
 /** The personal file, repository-relative, in git's spelling. */
 const PERSONAL_REL = '.devflow/config.json';
+/**
+ * The spellings a case-folding file system opens as `.devflow` and `config.json`
+ * beyond ASCII letter case. git's `icase` folds ASCII letters only, but APFS (the
+ * macOS default) compares names by full Unicode case folding, so it also opens
+ * `.devflow` (U+FB02 folds to "fl"), `config.json` (U+FB01 folds to "fi") and
+ * `config.jſon` (U+017F folds to "s") at the personal path. A probe of every code
+ * point on APFS finds no other one that folds into these names and none that it
+ * ignores. The code is written with escapes, so each code point is named.
+ */
+const DEVFLOW_SPELLINGS = Object.freeze(['.devflow', '.dev\u{FB02}ow']);
+const CONFIG_SPELLINGS = Object.freeze(['config.json', 'con\u{FB01}g.json', 'config.j\u{17F}on', 'con\u{FB01}g.j\u{17F}on']);
+/**
+ * The pathspecs of the tracking check (D-PERSONAL-UNTRACKED), each matched
+ * without regard to ASCII letter case, whatever the file system or
+ * `core.ignorecase`, and each spelled every way DEVFLOW_SPELLINGS and
+ * CONFIG_SPELLINGS list:
+ *   - the personal file itself, so a committed `.devflow/CONFIG.json`,
+ *     `.DEVFLOW/config.json` or `.devflow/config.jſon` counts where the file
+ *     system folds the name and opens it
+ *   - an index entry named `.devflow` ITSELF, which git records only for a symlink,
+ *     a gitlink (submodule) or a plain file, never for a directory: the character
+ *     class keeps `glob` from matching as a leading directory, so the many files
+ *     under a normal `.devflow/` are not listed. A tracked link or submodule
+ *     carries committed content to the path the personal file is opened at.
+ * An untracked `.devflow` link is the user's own setup and is not named here.
+ * The index check cannot see where such a link points: one that leads to tracked
+ * content (the same repository, or a linked worktree's link to the main
+ * checkout's `.devflow`) is read through, as every read of a linked folder is.
+ */
+const PERSONAL_TRACKING_PATHSPECS = Object.freeze([
+  ...DEVFLOW_SPELLINGS.flatMap(dir => CONFIG_SPELLINGS.map(file => ':(icase,literal)' + dir + '/' + file)),
+  ...DEVFLOW_SPELLINGS.map(dir => ':(icase,glob)[.]' + dir.slice(1)),
+]);
 /** The team file, repository-relative, in git's spelling. */
 const PROJECT_REL = '.devflow/project.json';
 
@@ -209,6 +270,10 @@ const PROJECT_REL = '.devflow/project.json';
  *   reviewPublication: Publication,
  *   compliance: { enabled: boolean, frameworks: readonly string[] },
  *   switches: { memory: SwitchState, learning: SwitchState, knowledge: SwitchState },
+ *   gateLevel: GateLevel,
+ *   gateLevelSource: GateLevelSource | null,
+ *   gateLevelInvalid: boolean,
+ *   gateLevelMachine: GateLevel | 'invalid' | null,
  *   repoCompliance: readonly string[] | null,
  *   defaultBranchCompliance: readonly string[] | null,
  *   personalTracked: boolean,
@@ -218,6 +283,14 @@ const PROJECT_REL = '.devflow/project.json';
  *   ok              false only for a fail-closed resolution — the whole-file
  *                   rule's included, which still carries every readable lens
  *   compliance      enabled with no frameworks is `generic`
+ *   gateLevelSource the layer that decided the level. null only for a whole-line
+ *                   fail-closed result (`ok` false), which has no deciding layer
+ *   gateLevelInvalid the deciding layer holds a malformed level, so `gateLevel` is
+ *                   `full`; the raw value is never carried
+ *   gateLevelMachine the machine layer's own reading, whoever decided: a level,
+ *                   `invalid` for a present malformed value, or null for none
+ *                   recorded. On a result that never read the manifest (git did not
+ *                   answer, or an internal error) null means not read
  *   repoCompliance  the worktree project.json's ids, or null when it declares
  *                   none (a malformed declaration reads as [] — generic)
  *   defaultBranchCompliance  the default branch's tracking copy's ids, the same
@@ -271,6 +344,10 @@ const FAIL_CLOSED_SETTINGS = Object.freeze({
     learning: Object.freeze({ on: true, source: /** @type {SwitchSource} */ ('machine') }),
     knowledge: Object.freeze({ on: false, source: /** @type {SwitchSource} */ ('machine') }),
   }),
+  gateLevel: /** @type {GateLevel} */ ('full'),
+  gateLevelSource: null,
+  gateLevelInvalid: false,
+  gateLevelMachine: null,
   repoCompliance: null,
   defaultBranchCompliance: null,
   personalTracked: false,
@@ -344,6 +421,23 @@ function machineCompliance(manifest) {
   return raw.enabled ? projectConfig.normalizeComplianceIds(raw.frameworks) : null;
 }
 
+/**
+ * src/core/gate-level.ts machineGateLevel exactly, and total: null when no level
+ * is recorded (not an object, `features` not an object, or no own `gateLevel`
+ * key), `invalid` when the key is present and is not one of the three words,
+ * else the level. The learning-capture hook folds a manifest of any shape, so
+ * this must never throw.
+ *
+ * @param {unknown} manifest
+ * @returns {GateLevel | 'invalid' | null}
+ */
+function machineGateLevel(manifest) {
+  if (!isPlainObject(manifest) || !isPlainObject(manifest.features)) return null;
+  if (!Object.prototype.hasOwnProperty.call(manifest.features, 'gateLevel')) return null;
+  const value = manifest.features.gateLevel;
+  return GATE_LEVELS.includes(value) ? /** @type {GateLevel} */ (value) : 'invalid';
+}
+
 // ---------------------------------------------------------------------------
 // The fold (the functional core)
 //
@@ -549,6 +643,42 @@ function foldSwitch(project, personal, manifest, feature) {
   return Object.freeze({ on: true, source: 'machine' });
 }
 
+/**
+ * The gate level, from two keys and nothing else:
+ *   1. a valid personal `gateLevel` wins (source `personal`);
+ *   2. a malformed personal `gateLevel` is `full` (source `personal`, invalid) and
+ *      never falls through to the machine value — a typo must not hand the choice
+ *      to a layer the user did not mean;
+ *   3. else a valid machine `features.gateLevel` (source `machine`);
+ *   4. else a malformed machine value is `full` (source `machine`, invalid);
+ *   5. else `standard` (source `default`).
+ * Either layer may raise or lower the level: it is not a switch, and narrow-only
+ * does not apply to it. An unreadable personal file reads as malformed, so a
+ * caller that folds it directly never sees the machine value win over it. The
+ * machine layer's own reading is carried whichever layer decided.
+ *
+ * @param {any} personal
+ * @param {unknown} manifest
+ * @returns {Pick<Settings, 'gateLevel' | 'gateLevelSource' | 'gateLevelInvalid' | 'gateLevelMachine'>}
+ */
+function foldGateLevel(personal, manifest) {
+  const machine = machineGateLevel(manifest);
+  const own = fieldIn(personal, 'gateLevel', 'malformed');
+  if (own.kind === 'valid') {
+    return { gateLevel: own.value, gateLevelSource: 'personal', gateLevelInvalid: false, gateLevelMachine: machine };
+  }
+  if (own.kind === 'malformed') {
+    return { gateLevel: 'full', gateLevelSource: 'personal', gateLevelInvalid: true, gateLevelMachine: machine };
+  }
+  if (machine === 'invalid') {
+    return { gateLevel: 'full', gateLevelSource: 'machine', gateLevelInvalid: true, gateLevelMachine: machine };
+  }
+  if (machine !== null) {
+    return { gateLevel: machine, gateLevelSource: 'machine', gateLevelInvalid: false, gateLevelMachine: machine };
+  }
+  return { gateLevel: 'standard', gateLevelSource: 'default', gateLevelInvalid: false, gateLevelMachine: null };
+}
+
 /**
  * The whole-file rule's resolution (D-SETTINGS-LINE): the fail-closed values,
  * naming the layer whose file could not be read, except the compliance lens —
@@ -567,6 +697,8 @@ function unreadableSettings(layer, inputs) {
   const lens = foldCompliance(inputs.project, inputs.manifest, defaultBranch);
   return Object.freeze({
     ...FAIL_CLOSED_SETTINGS,
+    // The level stays `full` with no deciding layer, but a readable manifest still shows its own value.
+    gateLevelMachine: machineGateLevel(inputs.manifest),
     compliance: lens.compliance,
     repoCompliance: layer === 'project' ? null : lens.repoCompliance,
     defaultBranchCompliance: lens.defaultBranchCompliance,
@@ -595,6 +727,7 @@ function foldSettings(inputs) {
       learning: foldSwitch(project, personal, manifest, 'learning'),
       knowledge: foldSwitch(project, personal, manifest, 'knowledge'),
     }),
+    ...foldGateLevel(personal, manifest),
     repoCompliance: lens.repoCompliance,
     defaultBranchCompliance: lens.defaultBranchCompliance,
     personalTracked: inputs.personalTracked === true,
@@ -667,26 +800,47 @@ function gitToplevel(exec, dir) {
  * not personal: a contributor's branch that commits one (`git add -f`) would
  * otherwise lift a maintainer's local run of that branch past the publication
  * ceiling. A tracked copy is ignored entirely, exactly as if absent, and main()
- * tells the user to untrack it. The check is `git ls-files --error-unmatch`,
- * which reads the index without refreshing or writing it. Reading the index
- * runs a configured `core.fsmonitor` hook — an arbitrary command from the
- * repository's config, and on macOS the builtin daemon's start-up — so the
- * call turns it off for itself (`-c core.fsmonitor=false`, D-NO-FSMONITOR):
- * this resolver runs from session hooks and must stay a pure read.
- *   tracked    exit 0
- *   untracked  any other answered exit (1: no such index entry; outside a
- *              repository git answers 128, and there is nothing to track)
- *   unknown    git did not answer — whether the file is personal cannot be
- *              known, so it is unreadable and its keys fail closed
+ * tells the user to untrack it.
+ *
+ * The question is whether COMMITTED content can reach the path the personal file
+ * is opened at, `<root>/.devflow/config.json`. The OS follows a symlinked
+ * `.devflow`, resolves a submodule's checkout there, and on a case-folding file
+ * system opens `CONFIG.json`, `.DEVFLOW/config.json` or `config.jſon` for it, so
+ * the answer is not only "is this exact path in the index". One `git ls-files -z`
+ * over PERSONAL_TRACKING_PATHSPECS asks all of it at once — no further git call:
+ * any output is a tracked entry that reaches the path (the file in any spelling
+ * the file system folds to it, or `.devflow` itself as a symlink, gitlink or
+ * file). It reads the index without
+ * refreshing or writing it. Reading the index runs a configured `core.fsmonitor`
+ * hook — an arbitrary command from the repository's config, and on macOS the
+ * builtin daemon's start-up — so the call turns it off for itself
+ * (`-c core.fsmonitor=false`, D-NO-FSMONITOR): this resolver runs from session
+ * hooks and must stay a pure read.
+ *   tracked    at least one entry listed, whatever the exit status
+ *   untracked  exit 0 with nothing listed; and, unless `rootConfirmed`, any other
+ *              answered exit (outside a repository git answers 128, and there is
+ *              nothing to track)
+ *   unknown    git did not answer, or its listing overflowed LINE_MAX_BUFFER; and,
+ *              with `rootConfirmed`, an answered non-zero exit with nothing listed —
+ *              inside a repository the call has no reason to fail except a git that
+ *              cannot read its index. Whether the file is personal cannot be known,
+ *              so it is unreadable and its keys fail closed
+ * `--no-literal-pathspecs` leads the argv: an inherited GIT_LITERAL_PATHSPECS=1
+ * would read every pathspec as a plain path, magic included, list nothing and
+ * read as untracked.
  *
  * @param {ExecFn} exec
  * @param {string} root
+ * @param {boolean} rootConfirmed  git has already named `root` as a repository's top level
  * @returns {'tracked' | 'untracked' | 'unknown'}
  */
-function personalTracking(exec, root) {
-  const res = runGit(exec, root, ['-c', 'core.fsmonitor=false', 'ls-files', '--error-unmatch', '--', PERSONAL_REL], LINE_MAX_BUFFER);
+function personalTracking(exec, root, rootConfirmed) {
+  const res = runGit(exec, root,
+    ['--no-literal-pathspecs', '-c', 'core.fsmonitor=false', 'ls-files', '-z', '--', ...PERSONAL_TRACKING_PATHSPECS], LINE_MAX_BUFFER);
   if (!res.answered) return 'unknown';
-  return res.ok ? 'tracked' : 'untracked';
+  if (res.stdout.length > 0) return 'tracked';
+  if (res.ok) return 'untracked';
+  return rootConfirmed ? 'unknown' : 'untracked';
 }
 
 /**
@@ -727,10 +881,13 @@ function existsNoFollow(filePath) {
  * cannot disagree about a symlink, a size, a BOM, a duplicated key — or a
  * config.json git tracks (D-PERSONAL-UNTRACKED), which is absent to both. Its only
  * subprocess is that tracking check, made only when config.json exists; never
- * throws on a missing or unreadable file.
+ * throws on a missing or unreadable file. `deps.rootConfirmed` is for a caller
+ * that has already had git name `root`: the tracking check then reads a git that
+ * answers non-zero as unknown. The hooks do not pass it, and a root outside any
+ * repository reads as untracked.
  *
  * @param {string} root
- * @param {{ exec?: ExecFn }} [deps]
+ * @param {{ exec?: ExecFn, rootConfirmed?: boolean }} [deps]
  * @returns {RepoLayers}
  */
 function readRepoLayers(root, deps) {
@@ -738,7 +895,7 @@ function readRepoLayers(root, deps) {
   const devflow = path.join(root, '.devflow');
   const project = readConfigFile(path.join(devflow, 'project.json'), projectConfig.parseProjectBytes);
   const personalPath = path.join(devflow, 'config.json');
-  const tracking = existsNoFollow(personalPath) ? personalTracking(exec, root) : 'untracked';
+  const tracking = existsNoFollow(personalPath) ? personalTracking(exec, root, Boolean(deps && deps.rootConfirmed)) : 'untracked';
   const personal = tracking === 'tracked' ? projectConfig.parsePersonalBytes(null)
     : tracking === 'unknown' ? Object.freeze({ kind: 'invalid' })
       : readConfigFile(personalPath, projectConfig.parsePersonalBytes);
@@ -796,7 +953,7 @@ function resolveSettings(opts, deps) {
       const none = projectConfig.parseProjectBytes(null);
       return foldSettings({ project: none, personal: none, manifest, retiredPolicyFile: false });
     }
-    const layers = readRepoLayers(toplevel.root, { exec });
+    const layers = readRepoLayers(toplevel.root, { exec, rootConfirmed: true });
     /** @type {SettingsInputs} */
     const inputs = {
       project: layers.project,
@@ -847,7 +1004,8 @@ function formatSettingsLine(s) {
     + ' COMPLIANCE=' + complianceToken(s.compliance)
     + ' MEMORY=' + onOff(s.switches.memory)
     + ' LEARNING=' + onOff(s.switches.learning)
-    + ' KNOWLEDGE=' + onOff(s.switches.knowledge);
+    + ' KNOWLEDGE=' + onOff(s.switches.knowledge)
+    + ' GATE_LEVEL=' + s.gateLevel;
 }
 
 /**
@@ -990,8 +1148,16 @@ function main(argv, deps) {
   }
   const settings = resolveSettings({ dir: args.dir }, { exec: d.exec });
   if (settings.personalTracked) {
-    process.stderr.write('resolve-settings: warning: ' + PERSONAL_REL + ' is tracked by git, so it is ignored'
-      + ' — it holds personal settings; untrack it with: git rm --cached ' + PERSONAL_REL + '\n');
+    process.stderr.write('resolve-settings: warning: Git tracks an entry at or under ' + PERSONAL_REL
+      + ', so devflow ignores that file. It holds personal settings. Find the entry in the output of: git ls-files.'
+      + ' Untrack it with: git rm --cached <entry>. Then check the file contents, or delete the file.'
+      + ' Untracking leaves the committed bytes on disk as your personal file.\n');
+  }
+  if (settings.gateLevelInvalid) {
+    // The layer and the field state only: a raw config value never reaches a terminal.
+    process.stderr.write('resolve-settings: warning: gateLevel in '
+      + (settings.gateLevelSource === 'personal' ? PERSONAL_REL : '~/.devflow/manifest.json')
+      + ' is not one of ' + GATE_LEVELS.join(', ') + ' — GATE_LEVEL=full applies\n');
   }
   if (settings.unreadable !== null) {
     process.stderr.write('resolve-settings: ' + (settings.unreadable === 'project' ? PROJECT_REL : PERSONAL_REL)
@@ -1044,6 +1210,8 @@ module.exports = Object.freeze({
   SETTINGS_LINE_RE,
   SETTINGS_FAIL_CLOSED_LINE,
   parseArgs,
+  machineGateLevel,
+  foldGateLevel,
   foldSettings,
   readRepoLayers,
   resolveSettings,