@nuucognition/flint-cli 0.5.5 → 0.5.6-dev.0

package/dist/index.js

@@ -1,5 +1,7 @@
 import {
   LiveSessionManager,
+  OBSIDIAN_REPO_URL,
+  OBSIDIAN_WINDOWS_REPO_URL,
   STANDARD_DIRECTORIES,
   TranscriptWatcher,
   addCodebaseReference,
@@ -121,7 +123,7 @@ import {
   updateSession,
   updateShards,
   updateSourceRepository
-} from "./chunk-XWUP7WHQ.js";
+} from "./chunk-WMXC6KO6.js";
 import {
   cleanRegistryFile,
   findFlintByName,
@@ -132,7 +134,7 @@ import {
   registerFlintByPath,
   unregisterFlint,
   upsertFlintEntry
-} from "./chunk-C66KJDI7.js";
+} from "./chunk-X6OG5PEE.js";
 import "./chunk-V7YA5RXL.js";
 import {
   generateSourceMeshExportMetadata,
@@ -148,7 +150,7 @@ import {
   resolveDocument,
   scanExportEligible,
   scanExports
-} from "./chunk-VAJMJ47E.js";
+} from "./chunk-6MPRSFXI.js";
 import {
   addExportToConfig,
   addLatticeDeclaration,
@@ -170,6 +172,7 @@ import {
   hasFlintJson,
   hasFlintToml,
   isLocalShard,
+  parse,
   readFlintJson,
   readFlintToml,
   readLatticesState,
@@ -184,14 +187,227 @@ import {
   writeFlintJson,
   writeFlintToml
 } from "./chunk-CBGQBE6C.js";
+import {
+  __commonJS,
+  __toESM
+} from "./chunk-JSBRDJBE.js";
+
+// ../../node_modules/.pnpm/balanced-match@1.0.2/node_modules/balanced-match/index.js
+var require_balanced_match = __commonJS({
+  "../../node_modules/.pnpm/balanced-match@1.0.2/node_modules/balanced-match/index.js"(exports, module) {
+    "use strict";
+    module.exports = balanced;
+    function balanced(a, b, str) {
+      if (a instanceof RegExp) a = maybeMatch(a, str);
+      if (b instanceof RegExp) b = maybeMatch(b, str);
+      var r = range(a, b, str);
+      return r && {
+        start: r[0],
+        end: r[1],
+        pre: str.slice(0, r[0]),
+        body: str.slice(r[0] + a.length, r[1]),
+        post: str.slice(r[1] + b.length)
+      };
+    }
+    function maybeMatch(reg, str) {
+      var m = str.match(reg);
+      return m ? m[0] : null;
+    }
+    balanced.range = range;
+    function range(a, b, str) {
+      var begs, beg, left, right, result;
+      var ai = str.indexOf(a);
+      var bi = str.indexOf(b, ai + 1);
+      var i = ai;
+      if (ai >= 0 && bi > 0) {
+        if (a === b) {
+          return [ai, bi];
+        }
+        begs = [];
+        left = str.length;
+        while (i >= 0 && !result) {
+          if (i == ai) {
+            begs.push(i);
+            ai = str.indexOf(a, i + 1);
+          } else if (begs.length == 1) {
+            result = [begs.pop(), bi];
+          } else {
+            beg = begs.pop();
+            if (beg < left) {
+              left = beg;
+              right = bi;
+            }
+            bi = str.indexOf(b, i + 1);
+          }
+          i = ai < bi && ai >= 0 ? ai : bi;
+        }
+        if (begs.length) {
+          result = [left, right];
+        }
+      }
+      return result;
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/brace-expansion@2.0.2/node_modules/brace-expansion/index.js
+var require_brace_expansion = __commonJS({
+  "../../node_modules/.pnpm/brace-expansion@2.0.2/node_modules/brace-expansion/index.js"(exports, module) {
+    "use strict";
+    var balanced = require_balanced_match();
+    module.exports = expandTop;
+    var escSlash = "\0SLASH" + Math.random() + "\0";
+    var escOpen = "\0OPEN" + Math.random() + "\0";
+    var escClose = "\0CLOSE" + Math.random() + "\0";
+    var escComma = "\0COMMA" + Math.random() + "\0";
+    var escPeriod = "\0PERIOD" + Math.random() + "\0";
+    function numeric(str) {
+      return parseInt(str, 10) == str ? parseInt(str, 10) : str.charCodeAt(0);
+    }
+    function escapeBraces(str) {
+      return str.split("\\\\").join(escSlash).split("\\{").join(escOpen).split("\\}").join(escClose).split("\\,").join(escComma).split("\\.").join(escPeriod);
+    }
+    function unescapeBraces(str) {
+      return str.split(escSlash).join("\\").split(escOpen).join("{").split(escClose).join("}").split(escComma).join(",").split(escPeriod).join(".");
+    }
+    function parseCommaParts(str) {
+      if (!str)
+        return [""];
+      var parts = [];
+      var m = balanced("{", "}", str);
+      if (!m)
+        return str.split(",");
+      var pre = m.pre;
+      var body = m.body;
+      var post = m.post;
+      var p = pre.split(",");
+      p[p.length - 1] += "{" + body + "}";
+      var postParts = parseCommaParts(post);
+      if (post.length) {
+        p[p.length - 1] += postParts.shift();
+        p.push.apply(p, postParts);
+      }
+      parts.push.apply(parts, p);
+      return parts;
+    }
+    function expandTop(str) {
+      if (!str)
+        return [];
+      if (str.substr(0, 2) === "{}") {
+        str = "\\{\\}" + str.substr(2);
+      }
+      return expand2(escapeBraces(str), true).map(unescapeBraces);
+    }
+    function embrace(str) {
+      return "{" + str + "}";
+    }
+    function isPadded(el) {
+      return /^-?0\d/.test(el);
+    }
+    function lte(i, y) {
+      return i <= y;
+    }
+    function gte(i, y) {
+      return i >= y;
+    }
+    function expand2(str, isTop) {
+      var expansions = [];
+      var m = balanced("{", "}", str);
+      if (!m) return [str];
+      var pre = m.pre;
+      var post = m.post.length ? expand2(m.post, false) : [""];
+      if (/\$$/.test(m.pre)) {
+        for (var k = 0; k < post.length; k++) {
+          var expansion = pre + "{" + m.body + "}" + post[k];
+          expansions.push(expansion);
+        }
+      } else {
+        var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
+        var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
+        var isSequence = isNumericSequence || isAlphaSequence;
+        var isOptions = m.body.indexOf(",") >= 0;
+        if (!isSequence && !isOptions) {
+          if (m.post.match(/,(?!,).*\}/)) {
+            str = m.pre + "{" + m.body + escClose + m.post;
+            return expand2(str);
+          }
+          return [str];
+        }
+        var n;
+        if (isSequence) {
+          n = m.body.split(/\.\./);
+        } else {
+          n = parseCommaParts(m.body);
+          if (n.length === 1) {
+            n = expand2(n[0], false).map(embrace);
+            if (n.length === 1) {
+              return post.map(function(p) {
+                return m.pre + n[0] + p;
+              });
+            }
+          }
+        }
+        var N;
+        if (isSequence) {
+          var x = numeric(n[0]);
+          var y = numeric(n[1]);
+          var width = Math.max(n[0].length, n[1].length);
+          var incr = n.length == 3 ? Math.abs(numeric(n[2])) : 1;
+          var test = lte;
+          var reverse = y < x;
+          if (reverse) {
+            incr *= -1;
+            test = gte;
+          }
+          var pad3 = n.some(isPadded);
+          N = [];
+          for (var i = x; test(i, y); i += incr) {
+            var c;
+            if (isAlphaSequence) {
+              c = String.fromCharCode(i);
+              if (c === "\\")
+                c = "";
+            } else {
+              c = String(i);
+              if (pad3) {
+                var need = width - c.length;
+                if (need > 0) {
+                  var z = new Array(need + 1).join("0");
+                  if (i < 0)
+                    c = "-" + z + c.slice(1);
+                  else
+                    c = z + c;
+                }
+              }
+            }
+            N.push(c);
+          }
+        } else {
+          N = [];
+          for (var j = 0; j < n.length; j++) {
+            N.push.apply(N, expand2(n[j], false));
+          }
+        }
+        for (var j = 0; j < N.length; j++) {
+          for (var k = 0; k < post.length; k++) {
+            var expansion = pre + N[j] + post[k];
+            if (!isTop || isSequence || expansion)
+              expansions.push(expansion);
+          }
+        }
+      }
+      return expansions;
+    }
+  }
+});
 
 // src/index.ts
-import { Command as Command37 } from "commander";
+import { Command as Command38 } from "commander";
 import { readFileSync as readFileSync11, existsSync as existsSync15, cpSync, mkdirSync as mkdirSync5, readdirSync as readdirSync8 } from "fs";
 import { fileURLToPath as fileURLToPath4 } from "url";
-import { dirname as dirname4, join as join19 } from "path";
+import { dirname as dirname4, join as join20 } from "path";
 import { homedir as homedir11 } from "os";
-import pc42 from "picocolors";
+import pc43 from "picocolors";
 
 // ../../../main/packages/cli-core/dist/index.js
 import { homedir } from "os";
@@ -275,7 +491,7 @@ function skipVoid(str, ptr, banNewLines, banComments) {
     ptr++;
   return banComments || c !== "#" ? ptr : skipVoid(str, skipComment(str, ptr), banNewLines);
 }
-function skipUntil(str, ptr, sep, end, banNewLines = false) {
+function skipUntil(str, ptr, sep2, end, banNewLines = false) {
   if (!end) {
     ptr = indexOfNewline(str, ptr);
     return ptr < 0 ? str.length : ptr;
@@ -284,7 +500,7 @@ function skipUntil(str, ptr, sep, end, banNewLines = false) {
     let c = str[i];
     if (c === "#") {
       i = indexOfNewline(str, i);
-    } else if (c === sep) {
+    } else if (c === sep2) {
       return i + 1;
     } else if (c === end || banNewLines && (c === "\n" || c === "\r" && str[i + 1] === "\n")) {
       return i;
@@ -325,18 +541,18 @@ var TomlDate = class _TomlDate extends Date {
     let hasTime = true;
     let offset = "Z";
     if (typeof date === "string") {
-      let match = date.match(DATE_TIME_RE);
-      if (match) {
-        if (!match[1]) {
+      let match2 = date.match(DATE_TIME_RE);
+      if (match2) {
+        if (!match2[1]) {
           hasDate = false;
           date = `0000-01-01T${date}`;
         }
-        hasTime = !!match[2];
+        hasTime = !!match2[2];
         hasTime && date[10] === " " && (date = date.replace(" ", "T"));
-        if (match[2] && +match[2] > 23) {
+        if (match2[2] && +match2[2] > 23) {
           date = "";
         } else {
-          offset = match[3] || null;
+          offset = match2[3] || null;
           date = date.toUpperCase();
           if (!offset && hasTime)
             date += "Z";
@@ -820,7 +1036,7 @@ function peekTable(key, table, meta, type) {
   }
   return [k, t, state.c];
 }
-function parse(toml, { maxDepth = 1e3, integersAsBigInt } = {}) {
+function parse2(toml, { maxDepth = 1e3, integersAsBigInt } = {}) {
   let res = {};
   let meta = {};
   let tbl = res;
@@ -1189,8 +1405,8 @@ async function defaultBrowserId() {
     throw new Error("macOS only");
   }
   const { stdout } = await execFileAsync("defaults", ["read", "com.apple.LaunchServices/com.apple.launchservices.secure", "LSHandlers"]);
-  const match = /LSHandlerRoleAll = "(?!-)(?<id>[^"]+?)";\s+?LSHandlerURLScheme = (?:http|https);/.exec(stdout);
-  const browserId = match?.groups.id ?? "com.apple.Safari";
+  const match2 = /LSHandlerRoleAll = "(?!-)(?<id>[^"]+?)";\s+?LSHandlerURLScheme = (?:http|https);/.exec(stdout);
+  const browserId = match2?.groups.id ?? "com.apple.Safari";
   if (browserId === "com.apple.safari") {
     return "com.apple.Safari";
   }
@@ -1254,11 +1470,11 @@ async function defaultBrowser(_execFileAsync = execFileAsync3) {
     "/v",
     "ProgId"
   ]);
-  const match = /ProgId\s*REG_SZ\s*(?<id>\S+)/.exec(stdout);
-  if (!match) {
+  const match2 = /ProgId\s*REG_SZ\s*(?<id>\S+)/.exec(stdout);
+  if (!match2) {
     throw new UnknownBrowserError(`Cannot find Windows browser in stdout: ${JSON.stringify(stdout)}`);
   }
-  const { id } = match.groups;
+  const { id } = match2.groups;
   const browser = windowsBrowserProgIds[id];
   if (!browser) {
     throw new UnknownBrowserError(`Unknown browser ID: ${id}`);
@@ -1566,10 +1782,10 @@ function normalizeRuntimeMode(input) {
 function authEnvForMode(mode) {
   return mode === "dev" ? "dev" : "prod";
 }
-async function readConfigFile(path8) {
+async function readConfigFile(path10) {
   try {
-    const content = await fsReadFile(path8, "utf-8");
-    return parse(content);
+    const content = await fsReadFile(path10, "utf-8");
+    return parse2(content);
   } catch (error22) {
     if (error22.code === "ENOENT") {
       return null;
@@ -1577,10 +1793,10 @@ async function readConfigFile(path8) {
     throw error22;
   }
 }
-function readConfigFileSync(path8) {
+function readConfigFileSync(path10) {
   try {
-    const content = fsReadFileSync(path8, "utf-8");
-    return parse(content);
+    const content = fsReadFileSync(path10, "utf-8");
+    return parse2(content);
   } catch (error22) {
     if (error22.code === "ENOENT") {
       return null;
@@ -1588,25 +1804,25 @@ function readConfigFileSync(path8) {
     throw error22;
   }
 }
-async function writeConfigFile(path8, data) {
-  await mkdir(dirname(path8), { recursive: true });
-  await fsWriteFile(path8, `${stringify(data)}
+async function writeConfigFile(path10, data) {
+  await mkdir(dirname(path10), { recursive: true });
+  await fsWriteFile(path10, `${stringify(data)}
 `, "utf-8");
 }
-async function setConfigField(path8, key, value) {
-  const existing = await readConfigFile(path8) ?? {};
+async function setConfigField(path10, key, value) {
+  const existing = await readConfigFile(path10) ?? {};
   existing[key] = value;
-  await writeConfigFile(path8, existing);
+  await writeConfigFile(path10, existing);
 }
-async function setFeatureOverride(path8, featureId, enabled) {
-  const existing = await readConfigFile(path8) ?? {};
+async function setFeatureOverride(path10, featureId, enabled) {
+  const existing = await readConfigFile(path10) ?? {};
   const features = existing.features && typeof existing.features === "object" && !Array.isArray(existing.features) ? { ...existing.features } : {};
   features[featureId] = enabled;
   existing.features = features;
-  await writeConfigFile(path8, existing);
+  await writeConfigFile(path10, existing);
 }
-async function removeFeatureOverride(path8, featureId) {
-  const existing = await readConfigFile(path8);
+async function removeFeatureOverride(path10, featureId) {
+  const existing = await readConfigFile(path10);
   if (!existing) return;
   const features = existing.features;
   if (!features || typeof features !== "object" || Array.isArray(features)) {
@@ -1619,7 +1835,7 @@ async function removeFeatureOverride(path8, featureId) {
   } else {
     existing.features = next;
   }
-  await writeConfigFile(path8, existing);
+  await writeConfigFile(path10, existing);
 }
 var CONFIG_FILENAME = "config.toml";
 function getConfigDir(cliname) {
@@ -1628,10 +1844,10 @@ function getConfigDir(cliname) {
 function getConfigPath(cliname) {
   return join(getConfigDir(cliname), CONFIG_FILENAME);
 }
-function mergeDefaults(config, defaults) {
-  if (!defaults) return config;
+function mergeDefaults(config, defaults2) {
+  if (!defaults2) return config;
   return {
-    ...defaults,
+    ...defaults2,
     ...config
   };
 }
@@ -1828,9 +2044,9 @@ async function loadAuth(env = "prod") {
 function loadAuthSync(env = "prod") {
   try {
     ensureNuuDirSync();
-    const path8 = authPath(env);
-    if (!existsSync(path8)) return null;
-    return normalizeCredentials(JSON.parse(readFileSync(path8, "utf-8")));
+    const path10 = authPath(env);
+    if (!existsSync(path10)) return null;
+    return normalizeCredentials(JSON.parse(readFileSync(path10, "utf-8")));
   } catch {
     return null;
   }
@@ -2319,6 +2535,7 @@ var FEATURES = createFeatureRegistry([
   { id: "code", tier: "prod", type: "command", description: "Launch AI coding agents", requiresAuth: false },
   { id: "orb", tier: "prod", type: "command", description: "Orbh meta-harness agent management", requiresAuth: false },
   { id: "server", tier: "prod", type: "command", description: "Flint runtime server", requiresAuth: false },
+  { id: "steel", tier: "prod", type: "command", description: "Manage Steel UI state", requiresAuth: false },
   { id: "runtime", tier: "dev", type: "command", description: "Flint runtime management", requiresAuth: false },
   { id: "obsidian.push", tier: "dev", type: "function", description: "Push obsidian config changes to remote", requiresAuth: false },
   { id: "agent.start", tier: "dev", type: "function", description: "Start AI agent session", requiresAuth: false }
@@ -2395,25 +2612,25 @@ function createProgressDisplay(label, total) {
 import { homedir as homedir3 } from "os";
 import { access } from "fs/promises";
 import { createInterface } from "readline";
-function abbreviatePath(path8) {
+function abbreviatePath(path10) {
   const home = homedir3();
-  if (path8.startsWith(home)) {
-    return path8.replace(home, "~");
+  if (path10.startsWith(home)) {
+    return path10.replace(home, "~");
   }
-  return path8;
+  return path10;
 }
-function expandPath(path8) {
-  if (path8.startsWith("~/")) {
-    return path8.replace("~", homedir3());
+function expandPath(path10) {
+  if (path10.startsWith("~/")) {
+    return path10.replace("~", homedir3());
   }
-  return path8;
+  return path10;
 }
 function padEnd(str, length) {
   return str.padEnd(length);
 }
-async function checkPathExists(path8) {
+async function checkPathExists(path10) {
   try {
-    await access(path8);
+    await access(path10);
     return true;
   } catch {
     return false;
@@ -2664,12 +2881,12 @@ function resolvePath(flint, fullPath) {
 }
 function printFlint(flint, opts) {
   const { nameColWidth, showStatus, fullPath, indent = "  " } = opts;
-  const path8 = resolvePath(flint, fullPath);
+  const path10 = resolvePath(flint, fullPath);
   const isBroken = showStatus && !flint.valid;
   const tags = formatTags(flint.tags);
   const nameCell = tags ? `${pc7.bold(flint.name)}  ${tags}` : pc7.bold(flint.name);
   const status = showStatus ? statusBadge(flint) + " " : "";
-  const pathColor = isBroken ? pc7.red(path8) : pc7.dim(path8);
+  const pathColor = isBroken ? pc7.red(path10) : pc7.dim(path10);
   console.log(`${indent}${pad(nameCell, nameColWidth)}${status}${pathColor}`);
   if (flint.description) {
     console.log(`${indent}  ${pc7.dim(truncate(flint.description, 65))}`);
@@ -2677,10 +2894,10 @@ function printFlint(flint, opts) {
 }
 function printGroupRow(flint, opts) {
   const { nameColWidth, showStatus, fullPath } = opts;
-  const path8 = resolvePath(flint, fullPath);
+  const path10 = resolvePath(flint, fullPath);
   const isBroken = showStatus && !flint.valid;
   const status = showStatus ? statusBadge(flint) + " " : "";
-  const pathColor = isBroken ? pc7.red(path8) : pc7.dim(path8);
+  const pathColor = isBroken ? pc7.red(path10) : pc7.dim(path10);
   console.log(`    ${pad(flint.name, nameColWidth)}${status}${pathColor}`);
 }
 function measureNameCol(flints) {
@@ -3208,9 +3425,9 @@ Uninstalled ${pc8.bold(result.name)}`));
         if (!existsSync3(gitDir)) continue;
         try {
           const url = execSync6("git remote get-url origin", { cwd: shardPath, encoding: "utf-8" }).trim();
-          const match = url.match(/(?:github\.com[/:])([\w.-]+\/[\w.-]+?)(?:\.git)?$/);
-          if (match) {
-            gitRemotes.set(shard.name, match[1]);
+          const match2 = url.match(/(?:github\.com[/:])([\w.-]+\/[\w.-]+?)(?:\.git)?$/);
+          if (match2) {
+            gitRemotes.set(shard.name, match2[1]);
           }
         } catch {
         }
@@ -3421,8 +3638,8 @@ Cloned ${pc8.bold(result.name)} for development`));
     try {
       const flintPath = await resolveFlint(options.path);
       const installed = await getInstalledShardsWithVersions(flintPath);
-      const match = resolveInstalledShardInfo(installed, name);
-      if (!match) {
+      const match2 = resolveInstalledShardInfo(installed, name);
+      if (!match2) {
         console.error(pc8.red(`
 Shard "${name}" not found.`));
         console.log(pc8.dim(`  Run ${pc8.cyan("flint shard list")} to see installed shards.`));
@@ -3430,11 +3647,11 @@ Shard "${name}" not found.`));
         return;
       }
       const declarations = await getShardDeclarations(flintPath);
-      const decl = declarations[match.name];
+      const decl = declarations[match2.name];
       const source = decl?.source || "";
       console.log(pc8.dim(`
-Transitioning ${match.folderName} to dev mode...`));
-      const result = await editShard(flintPath, match.folderName, source);
+Transitioning ${match2.folderName} to dev mode...`));
+      const result = await editShard(flintPath, match2.folderName, source);
       await updateGitignore(flintPath);
       console.log(pc8.green(`
 ${pc8.bold(result.name)} is now in dev mode`));
@@ -3451,8 +3668,8 @@ ${pc8.bold(result.name)} is now in dev mode`));
     try {
       const flintPath = await resolveFlint(options.path);
       const installed = await getInstalledShardsWithVersions(flintPath);
-      const match = resolveInstalledShardInfo(installed, name);
-      if (!match) {
+      const match2 = resolveInstalledShardInfo(installed, name);
+      if (!match2) {
         console.error(pc8.red(`
 Shard "${name}" not found.`));
         console.log(pc8.dim(`  Run ${pc8.cyan("flint shard list")} to see installed shards.`));
@@ -3460,8 +3677,8 @@ Shard "${name}" not found.`));
         return;
       }
       console.log(pc8.dim(`
-Freezing ${match.folderName}...`));
-      const result = await freezeShard(flintPath, match.folderName);
+Freezing ${match2.folderName}...`));
+      const result = await freezeShard(flintPath, match2.folderName);
       await updateGitignore(flintPath);
       console.log(pc8.green(`
 ${pc8.bold(result.name)} is now a normal shard`));
@@ -3478,17 +3695,17 @@ ${pc8.bold(result.name)} is now a normal shard`));
     try {
       const flintPath = await resolveFlint(options.path);
       const installed = await getInstalledShardsWithVersions(flintPath);
-      const match = resolveInstalledShardInfo(installed, name);
-      if (!match) {
+      const match2 = resolveInstalledShardInfo(installed, name);
+      if (!match2) {
         console.error(pc8.red(`
 Shard "${name}" not found.`));
         console.log(pc8.dim(`  Run ${pc8.cyan("flint shard list")} to see installed shards.`));
         console.log();
         return;
       }
-      const result = await addShardGitRemote(flintPath, match.folderName, url);
+      const result = await addShardGitRemote(flintPath, match2.folderName, url);
       console.log(pc8.green(`
-Remote added to ${pc8.bold(match.folderName)}`));
+Remote added to ${pc8.bold(match2.folderName)}`));
       console.log(pc8.dim(`  Remote: origin \u2192 ${url}`));
       console.log(pc8.dim(`  Source: ${result.ownerRepo}`));
       console.log();
@@ -3614,15 +3831,15 @@ Shard not found: "${identifier}"`));
       const installed = await getInstalledShardsWithVersions(flintPath);
       const targets = [];
       if (name) {
-        const match = resolveInstalledShardInfo(installed, name);
-        if (!match) {
+        const match2 = resolveInstalledShardInfo(installed, name);
+        if (!match2) {
           console.error(pc8.red(`
 Shard "${name}" not found.`));
           console.log(pc8.dim(`  Run ${pc8.cyan("flint shard list")} to see installed shards.`));
           console.log();
           return;
         }
-        targets.push(match);
+        targets.push(match2);
       } else {
         for (const s of installed) {
           targets.push({ folderName: s.folderName });
@@ -3749,8 +3966,8 @@ Reinstalling ${shorthand}...
       const { execSync: execSync6 } = await import("child_process");
       const flintPath = await resolveFlint(options.path);
       const installed = await getInstalledShardsWithVersions(flintPath);
-      const match = resolveInstalledShardInfo(installed, name);
-      if (!match) {
+      const match2 = resolveInstalledShardInfo(installed, name);
+      if (!match2) {
         console.error(pc8.red(`
 Shard "${name}" not found.`));
         console.log(pc8.dim(`  Run ${pc8.cyan("flint shard list")} to see installed shards.`));
@@ -3758,28 +3975,28 @@ Shard "${name}" not found.`));
         return;
       }
       const declarations = await getShardDeclarations(flintPath);
-      const declaration = declarations[match.name];
+      const declaration = declarations[match2.name];
       const gitInitMode = declaration ? resolveShardMode(declaration) : void 0;
       if (gitInitMode === "custom") {
         console.error(pc8.red(`
-"${match.folderName}" is a custom shard. Custom shards cannot have git remotes.`));
+"${match2.folderName}" is a custom shard. Custom shards cannot have git remotes.`));
         console.log();
         return;
       }
       if (gitInitMode !== "dev") {
         console.error(pc8.red(`
-"${match.folderName}" is not a dev shard.`));
+"${match2.folderName}" is not a dev shard.`));
         console.log();
         return;
       }
-      const shardPath = join5(flintPath, "Shards", match.folderName);
+      const shardPath = join5(flintPath, "Shards", match2.folderName);
       const gitDir = join5(shardPath, ".git");
       const hasGit = existsSync3(gitDir);
       if (hasGit) {
         try {
           const existing = execSync6("git remote get-url origin", { cwd: shardPath, stdio: "pipe" }).toString().trim();
           console.error(pc8.red(`
-"${match.folderName}" already has a remote: ${existing}`));
+"${match2.folderName}" already has a remote: ${existing}`));
           console.log(pc8.dim(`  Use ${pc8.cyan("flint shard push")} instead.`));
           console.log();
           return;
@@ -3787,7 +4004,7 @@ Shard "${name}" not found.`));
         }
       }
       console.log(pc8.bold(`
-Initializing ${match.folderName}...
+Initializing ${match2.folderName}...
 `));
       if (!hasGit) {
         execSync6("git init", { cwd: shardPath, stdio: "pipe" });
@@ -3798,7 +4015,7 @@ Initializing ${match.folderName}...
       execSync6('git commit -m "initial commit"', { cwd: shardPath, stdio: "pipe" });
       execSync6("git push -u origin main", { cwd: shardPath, stdio: "inherit" });
       console.log(pc8.green(`
-  ${pc8.bold(match.folderName)} pushed to ${pc8.dim(url)}`));
+  ${pc8.bold(match2.folderName)} pushed to ${pc8.dim(url)}`));
       console.log();
     } catch (err) {
       handleError(err);
@@ -3810,8 +4027,8 @@ Initializing ${match.folderName}...
       const { execSync: execSync6 } = await import("child_process");
       const flintPath = await resolveFlint(options.path);
       const installed = await getInstalledShardsWithVersions(flintPath);
-      const match = resolveInstalledShardInfo(installed, name);
-      if (!match) {
+      const match2 = resolveInstalledShardInfo(installed, name);
+      if (!match2) {
         console.error(pc8.red(`
 Shard "${name}" not found.`));
         console.log(pc8.dim(`  Run ${pc8.cyan("flint shard list")} to see installed shards.`));
@@ -3819,26 +4036,26 @@ Shard "${name}" not found.`));
         return;
       }
       const declarations = await getShardDeclarations(flintPath);
-      const declaration = declarations[match.name];
+      const declaration = declarations[match2.name];
       const shardMode = declaration ? resolveShardMode(declaration) : void 0;
       if (shardMode === "custom") {
         console.error(pc8.red(`
-"${match.folderName}" is a custom shard. Custom shards are workspace-specific and cannot be pushed.`));
+"${match2.folderName}" is a custom shard. Custom shards are workspace-specific and cannot be pushed.`));
         console.log();
         return;
       }
       if (shardMode !== "dev") {
         console.error(pc8.red(`
-"${match.folderName}" is not a dev shard. Only dev shards can be pushed.`));
+"${match2.folderName}" is not a dev shard. Only dev shards can be pushed.`));
         console.log();
         return;
       }
-      const shardPath = join5(flintPath, "Shards", match.folderName);
+      const shardPath = join5(flintPath, "Shards", match2.folderName);
       const gitDir = join5(shardPath, ".git");
       if (!existsSync3(gitDir)) {
         console.error(pc8.red(`
-"${match.folderName}" has no git repo. Initialize one first:`));
-        console.log(pc8.dim(`  cd "Shards/${match.folderName}" && git init && git remote add origin <url>`));
+"${match2.folderName}" has no git repo. Initialize one first:`));
+        console.log(pc8.dim(`  cd "Shards/${match2.folderName}" && git init && git remote add origin <url>`));
         console.log();
         return;
       }
@@ -3848,7 +4065,7 @@ Shard "${name}" not found.`));
           const unpushed = execSync6("git log @{u}..HEAD --oneline", { cwd: shardPath, encoding: "utf-8" }).trim();
           if (unpushed) {
             console.log(pc8.bold(`
-Pushing ${match.folderName}...
+Pushing ${match2.folderName}...
 `));
             execSync6("git push", { cwd: shardPath, stdio: "inherit" });
             console.log(pc8.green(`
@@ -3859,7 +4076,7 @@ Pushing ${match.folderName}...
         } catch {
         }
         console.log(pc8.dim(`
-No changes to push in "${match.folderName}".`));
+No changes to push in "${match2.folderName}".`));
         console.log();
         return;
       }
@@ -3872,9 +4089,9 @@ Invalid bump level "${level}". Use: patch, minor, or major.`));
           console.log();
           return;
         }
-        const { readFile: readFile9, writeFile: writeFile7 } = await import("fs/promises");
+        const { readFile: readFile10, writeFile: writeFile7 } = await import("fs/promises");
         const yamlPath = join5(shardPath, "shard.yaml");
-        const yamlContent = await readFile9(yamlPath, "utf-8");
+        const yamlContent = await readFile10(yamlPath, "utf-8");
         const versionMatch = yamlContent.match(/^version:\s*"?(\d+)\.(\d+)\.(\d+)"?/m);
         if (!versionMatch) {
           console.error(pc8.red(`
@@ -3889,10 +4106,10 @@ Could not parse version from shard.yaml.`));
         const updatedYaml = yamlContent.replace(/^version:\s*.+$/m, `version: "${bumpedVersion}"`);
         await writeFile7(yamlPath, updatedYaml, "utf-8");
       }
-      const baseMessage = options.message || `update ${match.folderName.replace(/^\(Dev\)\s*/, "")} shard`;
+      const baseMessage = options.message || `update ${match2.folderName.replace(/^\(Dev\)\s*/, "")} shard`;
       const message = bumpedVersion ? `v${bumpedVersion} ${baseMessage}` : baseMessage;
       console.log(pc8.bold(`
-Pushing ${match.folderName}...
+Pushing ${match2.folderName}...
 `));
       execSync6("git add -A", { cwd: shardPath, stdio: "pipe" });
       execSync6(`git commit -m "${message.replace(/"/g, '\\"')}"`, { cwd: shardPath, stdio: "pipe" });
@@ -3903,7 +4120,7 @@ Pushing ${match.folderName}...
         execSync6(`git push -u origin ${branch}`, { cwd: shardPath, stdio: "inherit" });
       }
       console.log(pc8.green(`
-  ${pc8.bold(match.folderName)} pushed.`));
+  ${pc8.bold(match2.folderName)} pushed.`));
       console.log(pc8.dim(`  ${message}`));
       console.log();
     } catch (err) {
@@ -3924,15 +4141,15 @@ Pushing ${match.folderName}...
       try {
         const flintPath = await resolveFlint(options.path);
         const installed = await getInstalledShardsWithVersions(flintPath);
-        const match = resolveInstalledShardInfo(installed, name);
-        if (!match) {
+        const match2 = resolveInstalledShardInfo(installed, name);
+        if (!match2) {
           console.error(pc8.red(`
 Shard "${name}" not found.`));
           console.log(pc8.dim(`  Run ${pc8.cyan("flint shard list")} to see installed shards.`));
           console.log();
           process.exit(1);
         }
-        const shardPath = join5(flintPath, "Shards", match.folderName);
+        const shardPath = join5(flintPath, "Shards", match2.folderName);
         const detail2 = await getShardInfo(flintPath, name);
         if (!detail2) {
           console.error(pc8.red(`
@@ -3940,7 +4157,7 @@ Cannot read shard info for "${name}".`));
           process.exit(1);
         }
         const declarations = await getShardDeclarations(flintPath);
-        const declaration = declarations[match.name];
+        const declaration = declarations[match2.name];
         let repo = "";
         if (declaration?.source) {
           const parsed = parseShardSource(declaration.source);
@@ -4969,11 +5186,12 @@ var REQUIRED_DIRS = [
   "Exports",
   "Workspace",
   "Workspace/Bench",
-  ".flint"
+  ".flint",
+  ".steel"
 ];
-async function exists(path8) {
+async function exists(path10) {
   try {
-    await access2(path8);
+    await access2(path10);
     return true;
   } catch {
     return false;
@@ -5198,9 +5416,9 @@ import pc12 from "picocolors";
 import { readFile as readFile4, stat } from "fs/promises";
 import { join as join7, basename as basename2 } from "path";
 import { createInterface as createInterface2 } from "readline";
-async function exists2(path8) {
+async function exists2(path10) {
   try {
-    await stat(path8);
+    await stat(path10);
     return true;
   } catch {
     return false;
@@ -5494,17 +5712,17 @@ import { resolve as resolve2 } from "path";
 import { platform as platform3 } from "os";
 import pc13 from "picocolors";
 var execAsync2 = promisify7(exec2);
-async function openInObsidian(path8) {
+async function openInObsidian(path10) {
   const os2 = platform3();
   if (os2 === "darwin") {
-    await execAsync2(`open -a "Obsidian" "${path8}"`);
+    await execAsync2(`open -a "Obsidian" "${path10}"`);
   } else if (os2 === "win32") {
-    await execAsync2(`start "" "Obsidian" "${path8}"`);
+    await execAsync2(`start "" "Obsidian" "${path10}"`);
   } else {
     try {
-      await execAsync2(`obsidian "${path8}"`);
+      await execAsync2(`obsidian "${path10}"`);
     } catch {
-      await execAsync2(`xdg-open "${path8}"`);
+      await execAsync2(`xdg-open "${path10}"`);
     }
   }
 }
@@ -6445,7 +6663,10 @@ import pc18 from "picocolors";
 import { execSync as execSync2, spawnSync as spawnSync2 } from "child_process";
 import { join as join8 } from "path";
 import { stat as stat2, rm as rm2 } from "fs/promises";
-var OBSIDIAN_REPO_URL = "https://github.com/NUU-Cognition/flint-dot-obsidian.git";
+import { platform as platform4 } from "os";
+function getExpectedRepoUrl() {
+  return platform4() === "win32" ? OBSIDIAN_WINDOWS_REPO_URL : OBSIDIAN_REPO_URL;
+}
 var obsidianCommand = new Command15("obsidian").description("Manage .obsidian configuration").option("-p, --path <dir>", "Path to flint (default: auto-detect)");
 obsidianCommand.command("update").description("Force pull latest .obsidian from remote (discards local changes)").action(async () => {
   const options = obsidianCommand.opts();
@@ -6462,11 +6683,20 @@ obsidianCommand.command("update").description("Force pull latest .obsidian from
     console.log(pc18.dim("Run `flint init` to create a new flint with .obsidian."));
     process.exit(1);
   }
-  console.log(pc18.dim("Fetching latest from remote..."));
   try {
-    execSync2("git fetch origin", { cwd: obsidianDir, stdio: "pipe" });
-    execSync2("git reset --hard origin/main", { cwd: obsidianDir, stdio: "pipe" });
-    console.log(pc18.green("Updated .obsidian to latest from remote."));
+    const expectedUrl = getExpectedRepoUrl();
+    const currentUrl = execSync2("git remote get-url origin", { cwd: obsidianDir, encoding: "utf-8" }).trim();
+    if (currentUrl !== expectedUrl) {
+      console.log(pc18.dim("Detected wrong platform repo. Re-cloning with correct one..."));
+      await rm2(obsidianDir, { recursive: true, force: true });
+      await cloneObsidian(flintPath);
+      console.log(pc18.green("Re-cloned .obsidian with correct platform repo."));
+    } else {
+      console.log(pc18.dim("Fetching latest from remote..."));
+      execSync2("git fetch origin", { cwd: obsidianDir, stdio: "pipe" });
+      execSync2("git reset --hard origin/main", { cwd: obsidianDir, stdio: "pipe" });
+      console.log(pc18.green("Updated .obsidian to latest from remote."));
+    }
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
     console.error(pc18.red(`Error updating .obsidian: ${message}`));
@@ -6519,25 +6749,25 @@ obsidianCommand.command("reset").description("Delete and re-clone .obsidian from
     process.exit(1);
   }
   const obsidianDir = join8(flintPath, ".obsidian");
-  let exists5 = false;
+  let exists6 = false;
   try {
     await stat2(obsidianDir);
-    exists5 = true;
+    exists6 = true;
   } catch {
   }
-  if (exists5 && !cmdOptions.force) {
+  if (exists6 && !cmdOptions.force) {
     console.log(pc18.yellow("Warning: This will delete your current .obsidian folder and re-clone from the template repo."));
     console.log(pc18.yellow("Any local changes will be lost."));
     console.log(pc18.dim("\nUse --force to skip this confirmation."));
     process.exit(1);
   }
   try {
-    if (exists5) {
+    if (exists6) {
       console.log(pc18.dim("Removing existing .obsidian..."));
       await rm2(obsidianDir, { recursive: true, force: true });
     }
     console.log(pc18.dim("Cloning .obsidian from template repo..."));
-    execSync2(`git clone ${OBSIDIAN_REPO_URL} "${obsidianDir}"`, { stdio: "pipe" });
+    await cloneObsidian(flintPath);
     console.log(pc18.green("Reset .obsidian to fresh state from template repo."));
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -7009,7 +7239,7 @@ repoCommand.command("add").description("Add a plate from a git repo").argument("
       getPlateDeclaration,
       nameFormats,
       updateGitignore: updateGitignore2
-    } = await import("./dist-RGQKIZQW.js");
+    } = await import("./dist-EAYA2DAP.js");
     const { proper, slug } = nameFormats(name);
     const existing = await getPlateDeclaration(flintPath, slug);
     if (existing) {
@@ -7021,7 +7251,7 @@ repoCommand.command("add").description("Add a plate from a git repo").argument("
 Cloning ${url}...`));
     await clonePlateFromRepo(flintPath, slug, url, platePath);
     await addPlateDeclaration(flintPath, slug, platePath, { title: proper });
-    const { setPlateRepo } = await import("./dist-RGQKIZQW.js");
+    const { setPlateRepo } = await import("./dist-EAYA2DAP.js");
     await setPlateRepo(flintPath, slug, url);
     await updateGitignore2(flintPath);
     console.log(pc22.green(`
@@ -7039,9 +7269,9 @@ Added plate: ${pc22.bold(proper)}`));
 repoCommand.command("remove").description("Remove a repo-sourced plate").argument("<name>", "Plate declaration name or slug").option("-p, --path <dir>", "Path to flint (default: auto-detect)").action(async (name, options) => {
   try {
     const flintPath = await resolveFlintPath2(options.path);
-    const { removePlateDeclaration, updateGitignore: updateGitignore2 } = await import("./dist-RGQKIZQW.js");
-    const { rm: rm5, stat: stat11 } = await import("fs/promises");
-    const { join: join20 } = await import("path");
+    const { removePlateDeclaration, updateGitignore: updateGitignore2 } = await import("./dist-EAYA2DAP.js");
+    const { rm: rm6, stat: stat11 } = await import("fs/promises");
+    const { join: join21 } = await import("path");
     const plate = await getPlate(flintPath, name);
     if (!plate) {
       console.error(pc22.red(`Error: Plate "${name}" not found.`));
@@ -7049,7 +7279,7 @@ repoCommand.command("remove").description("Remove a repo-sourced plate").argumen
     }
     try {
       await stat11(plate.path);
-      await rm5(plate.path, { recursive: true, force: true });
+      await rm6(plate.path, { recursive: true, force: true });
     } catch {
     }
     await removePlateDeclaration(flintPath, plate.declarationName);
@@ -7073,11 +7303,11 @@ plateCommand.command("install").description("Install a Plate from a git repo URL
       readPlateManifest,
       setPlateRepo,
       updateGitignore: updateGitignore2
-    } = await import("./dist-RGQKIZQW.js");
-    const { join: join20 } = await import("path");
-    const { mkdtemp: mkdtemp2, rm: rm5, rename: rename2 } = await import("fs/promises");
+    } = await import("./dist-EAYA2DAP.js");
+    const { join: join21 } = await import("path");
+    const { mkdtemp: mkdtemp2, rm: rm6, rename: rename3 } = await import("fs/promises");
     const { tmpdir: tmpdir2 } = await import("os");
-    const tmpDir = await mkdtemp2(join20(tmpdir2(), "flint-plate-"));
+    const tmpDir = await mkdtemp2(join21(tmpdir2(), "flint-plate-"));
     console.log(pc22.dim(`
 Cloning ${url}...`));
     try {
@@ -7085,7 +7315,7 @@ Cloning ${url}...`));
     } catch {
       const { execSync: execSync6 } = await import("child_process");
       execSync6(`git clone --depth 1 "${url}" "${tmpDir}"`, { timeout: 6e4, stdio: "ignore" });
-      await rm5(join20(tmpDir, ".git"), { recursive: true, force: true }).catch(() => {
+      await rm6(join21(tmpDir, ".git"), { recursive: true, force: true }).catch(() => {
       });
     }
     const manifest = await readPlateManifest(tmpDir);
@@ -7093,15 +7323,15 @@ Cloning ${url}...`));
     const title = manifest.title;
     const existing = await getPlate(flintPath, slug);
     if (existing) {
-      await rm5(tmpDir, { recursive: true, force: true });
+      await rm6(tmpDir, { recursive: true, force: true });
       console.error(pc22.red(`Error: Plate "${slug}" already exists.`));
       process.exit(1);
     }
     const { mkdir: mkdir9 } = await import("fs/promises");
     const platePath = `Plates/${title}`;
-    const absolutePlatePath = join20(flintPath, platePath);
-    await mkdir9(join20(flintPath, "Plates"), { recursive: true });
-    await rename2(tmpDir, absolutePlatePath);
+    const absolutePlatePath = join21(flintPath, platePath);
+    await mkdir9(join21(flintPath, "Plates"), { recursive: true });
+    await rename3(tmpDir, absolutePlatePath);
     await addPlateDeclaration(flintPath, slug, platePath, { title });
     await setPlateRepo(flintPath, slug, url);
     await updateGitignore2(flintPath);
@@ -7122,7 +7352,7 @@ Installed plate: ${pc22.bold(title)}`));
 plateCommand.command("push").description("Initialize a plate as a git repo, set remote, and push").argument("<name>", "Plate name").argument("<url>", "Git remote URL").option("-p, --path <dir>", "Path to flint (default: auto-detect)").action(async (name, url, options) => {
   try {
     const flintPath = await resolveFlintPath2(options.path);
-    const { setPlateRepo } = await import("./dist-RGQKIZQW.js");
+    const { setPlateRepo } = await import("./dist-EAYA2DAP.js");
     console.log(pc22.dim(`
 Pushing plate "${name}"...`));
     const result = await initPlateRepo(flintPath, name, url);
@@ -7148,7 +7378,7 @@ Pushing plate "${name}"...`));
 plateCommand.command("sync").description("Sync plates that have a repo configured").option("-p, --path <dir>", "Path to flint (default: auto-detect)").action(async (options) => {
   try {
     const flintPath = await resolveFlintPath2(options.path);
-    const { getPlateDeclarations, syncPlateRepos } = await import("./dist-RGQKIZQW.js");
+    const { getPlateDeclarations, syncPlateRepos } = await import("./dist-EAYA2DAP.js");
     const declarations = await getPlateDeclarations(flintPath);
     const hasRepos = Object.values(declarations).some((d) => d.repo);
     if (!hasRepos) {
@@ -7424,9 +7654,9 @@ repoCommand2.addCommand(
     }
   })
 );
-async function fileExists(path8) {
+async function fileExists(path10) {
   try {
-    await stat3(path8);
+    await stat3(path10);
     return true;
   } catch {
     return false;
@@ -7445,12 +7675,12 @@ function parseExportRef(ref) {
 }
 async function findFlintByName2(name) {
   const flints = await getFlintRegistry();
-  let match = flints.find((f) => f.name === name);
-  if (match) return match;
-  match = flints.find((f) => getSimplifiedName(f.name) === name);
-  if (match) return match;
-  match = flints.find((f) => getSimplifiedName(basename3(f.path)) === name);
-  if (match) return match;
+  let match2 = flints.find((f) => f.name === name);
+  if (match2) return match2;
+  match2 = flints.find((f) => getSimplifiedName(f.name) === name);
+  if (match2) return match2;
+  match2 = flints.find((f) => getSimplifiedName(basename3(f.path)) === name);
+  if (match2) return match2;
   return null;
 }
 async function getRegisteredFlintsWithExports() {
@@ -7712,9 +7942,9 @@ function readPinsToml(latticeRoot) {
   if (!recordsMatch) return [];
   const recordsStr = recordsMatch[1];
   const entryPattern = /\{\s*id\s*=\s*"([^"]+)"\s*,\s*title\s*=\s*"([^"]+)"\s*\}/g;
-  let match;
-  while ((match = entryPattern.exec(recordsStr)) !== null) {
-    records.push({ id: match[1], title: match[2] });
+  let match2;
+  while ((match2 = entryPattern.exec(recordsStr)) !== null) {
+    records.push({ id: match2[1], title: match2[2] });
   }
   return records;
 }
@@ -8045,7 +8275,7 @@ var latticeCommand = new Command21("lattice").description("Manage lattice connec
 // src/commands/server.ts
 import { Command as Command22 } from "commander";
 import { createRequire } from "module";
-import path6 from "path";
+import path8 from "path";
 import { spawn as spawn6 } from "child_process";
 import { stat as stat6 } from "fs/promises";
 import pc25 from "picocolors";
@@ -8054,8 +8284,8 @@ import pc25 from "picocolors";
 import Fastify from "fastify";
 import fastifyCors from "@fastify/cors";
 import fastifyStatic from "@fastify/static";
-import { stat as stat4 } from "fs/promises";
-import path5 from "path";
+import { stat as stat5 } from "fs/promises";
+import path7 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { join as join43 } from "path";
 
@@ -10358,12 +10588,12 @@ function readGeminiSessionId(transcriptPath) {
 function parseGeminiSessionList(output) {
   const mapping = /* @__PURE__ */ new Map();
   for (const line of output.split("\n")) {
-    const match = line.match(/^\s*(\d+)\.\s+.*\[(.+?)\]\s*$/);
-    if (!match) {
+    const match2 = line.match(/^\s*(\d+)\.\s+.*\[(.+?)\]\s*$/);
+    if (!match2) {
       continue;
     }
-    const index = match[1];
-    const sessionId = match[2];
+    const index = match2[1];
+    const sessionId = match2[2];
     if (index && sessionId) {
       mapping.set(sessionId, index);
     }
@@ -10766,209 +10996,2241 @@ function killHarnessProcess(options) {
 }
 
 // ../../packages/flint-server/dist/index.js
-import {
-  createRuntime,
-  computeRuntimeId
-} from "@nuucognition/flint-runtime";
-import { existsSync as existsSync10, watch as watch3 } from "fs";
-import { stat as stat5 } from "fs/promises";
-import path3 from "path";
-import { mkdir as mkdir5, readFile as readFile6, writeFile as writeFile3 } from "fs/promises";
-import { homedir as homedir6 } from "os";
-import { join as join11, resolve as resolve7 } from "path";
-import { existsSync as existsSync23 } from "fs";
-import { stat as stat22, readFile as readFile22 } from "fs/promises";
-import path22 from "path";
-import { existsSync as existsSync33 } from "fs";
+import { randomUUID as randomUUID3, createHash as createHash2 } from "crypto";
+import { EventEmitter } from "events";
+import { readFile as readFile6, stat as stat4 } from "fs/promises";
 import { spawn as spawn5 } from "child_process";
-import { readFile as readFile32 } from "fs/promises";
-import path32 from "path";
-import { readdir as readdir2 } from "fs/promises";
 import path4 from "path";
-import { readdir as readdir22 } from "fs/promises";
-import { join as join23 } from "path";
-import { randomUUID as randomUUID3 } from "crypto";
-import { writeFile as writeFile22, mkdir as mkdir22, readdir as readdir3, readFile as readFile42, stat as stat32 } from "fs/promises";
-import { join as join33 } from "path";
-function sendApiError(reply, status, error3, message, extra = {}) {
-  return reply.code(status).send({ error: error3, message, ...extra });
-}
-var CONTENT_TYPES = {
-  ".css": "text/css; charset=utf-8",
-  ".html": "text/html; charset=utf-8",
-  ".js": "application/javascript; charset=utf-8",
-  ".json": "application/json; charset=utf-8",
-  ".map": "application/json; charset=utf-8",
-  ".mjs": "application/javascript; charset=utf-8",
-  ".png": "image/png",
-  ".svg": "image/svg+xml",
-  ".tsx": "text/plain; charset=utf-8",
-  ".txt": "text/plain; charset=utf-8",
-  ".woff": "font/woff",
-  ".woff2": "font/woff2"
-};
-function contentTypeFor(filePath) {
-  return CONTENT_TYPES[path3.extname(filePath).toLowerCase()] ?? "application/octet-stream";
-}
-function isImmutableAsset(filePath) {
-  return /\.[a-f0-9]{8,}\./i.test(path3.basename(filePath));
-}
-async function resolveFlintPath4(inputPath) {
-  const resolved = path3.resolve(inputPath);
-  const flintToml = path3.join(resolved, "flint.toml");
-  const flintState = path3.join(resolved, ".flint");
-  const hasConfig = await exists3(flintToml);
-  const hasState = await exists3(flintState);
-  if (!hasConfig && !hasState) {
-    throw new Error(`Not a Flint workspace: ${resolved}`);
-  }
-  return resolved;
-}
-async function exists3(targetPath) {
-  try {
-    await stat5(targetPath);
-    return true;
-  } catch {
-    return false;
+import chokidar from "chokidar";
+import { glob } from "glob";
+
+// ../../node_modules/.pnpm/minimatch@9.0.9/node_modules/minimatch/dist/esm/index.js
+var import_brace_expansion = __toESM(require_brace_expansion(), 1);
+
+// ../../node_modules/.pnpm/minimatch@9.0.9/node_modules/minimatch/dist/esm/assert-valid-pattern.js
+var MAX_PATTERN_LENGTH = 1024 * 64;
+var assertValidPattern = (pattern) => {
+  if (typeof pattern !== "string") {
+    throw new TypeError("invalid pattern");
   }
-}
-function toError(error3, fallbackMessage) {
-  if (error3 instanceof Error) {
-    return error3;
+  if (pattern.length > MAX_PATTERN_LENGTH) {
+    throw new TypeError("pattern is too long");
   }
-  return new Error(typeof error3 === "string" ? error3 : fallbackMessage);
-}
-function isUnsupportedRecursiveWatchError(error3) {
-  const code = typeof error3 === "object" && error3 !== null && "code" in error3 ? String(error3.code ?? "") : "";
-  return code === "ERR_FEATURE_UNAVAILABLE_ON_PLATFORM" || code === "ENOSYS" || code === "ENOTSUP";
-}
-function createResilientWatcher({
-  label,
-  targetPath,
-  recursive = false,
-  retryMs = 1e3,
-  onChange
-}) {
-  let watcher = null;
-  let retryTimer = null;
-  let closed = false;
-  const scheduleRestart = () => {
-    if (closed || retryTimer) {
-      return;
-    }
-    retryTimer = setTimeout(() => {
-      retryTimer = null;
-      start();
-    }, retryMs);
-    retryTimer.unref?.();
-  };
-  const handleWatchError = (error3) => {
-    const resolved = toError(error3, `${label} watcher failed`);
-    const unsupported = recursive && isUnsupportedRecursiveWatchError(error3);
-    watcher?.close();
-    watcher = null;
-    if (unsupported) {
-      console.warn(`[flint-server] ${label} watcher disabled: recursive fs.watch is not supported on this platform.`);
-      return;
+};
+
+// ../../node_modules/.pnpm/minimatch@9.0.9/node_modules/minimatch/dist/esm/brace-expressions.js
+var posixClasses = {
+  "[:alnum:]": ["\\p{L}\\p{Nl}\\p{Nd}", true],
+  "[:alpha:]": ["\\p{L}\\p{Nl}", true],
+  "[:ascii:]": ["\\x00-\\x7f", false],
+  "[:blank:]": ["\\p{Zs}\\t", true],
+  "[:cntrl:]": ["\\p{Cc}", true],
+  "[:digit:]": ["\\p{Nd}", true],
+  "[:graph:]": ["\\p{Z}\\p{C}", true, true],
+  "[:lower:]": ["\\p{Ll}", true],
+  "[:print:]": ["\\p{C}", true],
+  "[:punct:]": ["\\p{P}", true],
+  "[:space:]": ["\\p{Z}\\t\\r\\n\\v\\f", true],
+  "[:upper:]": ["\\p{Lu}", true],
+  "[:word:]": ["\\p{L}\\p{Nl}\\p{Nd}\\p{Pc}", true],
+  "[:xdigit:]": ["A-Fa-f0-9", false]
+};
+var braceEscape = (s) => s.replace(/[[\]\\-]/g, "\\$&");
+var regexpEscape = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+var rangesToString = (ranges) => ranges.join("");
+var parseClass = (glob2, position) => {
+  const pos = position;
+  if (glob2.charAt(pos) !== "[") {
+    throw new Error("not in a brace expression");
+  }
+  const ranges = [];
+  const negs = [];
+  let i = pos + 1;
+  let sawStart = false;
+  let uflag = false;
+  let escaping = false;
+  let negate = false;
+  let endPos = pos;
+  let rangeStart = "";
+  WHILE: while (i < glob2.length) {
+    const c = glob2.charAt(i);
+    if ((c === "!" || c === "^") && i === pos + 1) {
+      negate = true;
+      i++;
+      continue;
     }
-    console.warn(`[flint-server] ${label} watcher error: ${resolved.message}. Retrying.`);
-    scheduleRestart();
-  };
-  const start = () => {
-    if (closed) {
-      return;
+    if (c === "]" && sawStart && !escaping) {
+      endPos = i + 1;
+      break;
     }
-    if (!existsSync10(targetPath)) {
-      scheduleRestart();
-      return;
+    sawStart = true;
+    if (c === "\\") {
+      if (!escaping) {
+        escaping = true;
+        i++;
+        continue;
+      }
     }
-    try {
-      watcher = watch3(targetPath, { recursive }, (_eventType, filename) => {
-        onChange(filename);
-      });
-      watcher.on("error", handleWatchError);
-    } catch (error3) {
-      handleWatchError(error3);
+    if (c === "[" && !escaping) {
+      for (const [cls, [unip, u, neg]] of Object.entries(posixClasses)) {
+        if (glob2.startsWith(cls, i)) {
+          if (rangeStart) {
+            return ["$.", false, glob2.length - pos, true];
+          }
+          i += cls.length;
+          if (neg)
+            negs.push(unip);
+          else
+            ranges.push(unip);
+          uflag = uflag || u;
+          continue WHILE;
+        }
+      }
     }
-  };
-  start();
-  return {
-    close() {
-      closed = true;
-      if (retryTimer) {
-        clearTimeout(retryTimer);
-        retryTimer = null;
+    escaping = false;
+    if (rangeStart) {
+      if (c > rangeStart) {
+        ranges.push(braceEscape(rangeStart) + "-" + braceEscape(c));
+      } else if (c === rangeStart) {
+        ranges.push(braceEscape(c));
       }
-      watcher?.close();
-      watcher = null;
+      rangeStart = "";
+      i++;
+      continue;
     }
-  };
-}
-var RuntimeManager = class {
-  runtimes = /* @__PURE__ */ new Map();
-  async startRuntime(flintPath) {
-    const resolved = await resolveFlintPath4(flintPath);
-    const runtimeId = computeRuntimeId(resolved);
-    const existing = this.runtimes.get(runtimeId);
-    if (existing) {
-      return existing.getStatus();
+    if (glob2.startsWith("-]", i + 1)) {
+      ranges.push(braceEscape(c + "-"));
+      i += 2;
+      continue;
     }
-    const runtime2 = createRuntime({ flintPath: resolved });
-    await runtime2.start();
-    this.runtimes.set(runtimeId, runtime2);
-    return runtime2.getStatus();
-  }
-  listRuntimes() {
-    return Array.from(this.runtimes.values()).map((runtime2) => runtime2.getStatus());
+    if (glob2.startsWith("-", i + 1)) {
+      rangeStart = c;
+      i += 2;
+      continue;
+    }
+    ranges.push(braceEscape(c));
+    i++;
   }
-  getRuntime(id) {
-    return this.runtimes.get(id);
+  if (endPos < i) {
+    return ["", false, 0, false];
   }
-  async stopRuntime(id) {
-    const runtime2 = this.runtimes.get(id);
-    if (!runtime2) {
-      return false;
-    }
-    await runtime2.stop();
-    this.runtimes.delete(id);
-    return true;
+  if (!ranges.length && !negs.length) {
+    return ["$.", false, glob2.length - pos, true];
   }
-  async stopAll() {
-    const entries = Array.from(this.runtimes.entries());
-    await Promise.all(entries.map(async ([id, runtime2]) => {
-      await runtime2.stop();
-      this.runtimes.delete(id);
-    }));
+  if (negs.length === 0 && ranges.length === 1 && /^\\?.$/.test(ranges[0]) && !negate) {
+    const r = ranges[0].length === 2 ? ranges[0].slice(-1) : ranges[0];
+    return [regexpEscape(r), false, endPos - pos, false];
   }
+  const sranges = "[" + (negate ? "^" : "") + rangesToString(ranges) + "]";
+  const snegs = "[" + (negate ? "" : "^") + rangesToString(negs) + "]";
+  const comb = ranges.length && negs.length ? "(" + sranges + "|" + snegs + ")" : ranges.length ? sranges : snegs;
+  return [comb, uflag, endPos - pos, true];
 };
-var REGISTRY_PATH = join11(homedir6(), ".nuucognition", "servers.json");
-function getRegistryDir() {
-  return join11(homedir6(), ".nuucognition");
-}
-async function readServerRegistry() {
-  try {
-    const content = await readFile6(REGISTRY_PATH, "utf-8");
-    const data = JSON.parse(content);
-    return data.servers ?? [];
-  } catch (error3) {
-    if (error3.code === "ENOENT") {
-      return [];
+
+// ../../node_modules/.pnpm/minimatch@9.0.9/node_modules/minimatch/dist/esm/unescape.js
+var unescape = (s, { windowsPathsNoEscape = false } = {}) => {
+  return windowsPathsNoEscape ? s.replace(/\[([^\/\\])\]/g, "$1") : s.replace(/((?!\\).|^)\[([^\/\\])\]/g, "$1$2").replace(/\\([^\/])/g, "$1");
+};
+
+// ../../node_modules/.pnpm/minimatch@9.0.9/node_modules/minimatch/dist/esm/ast.js
+var _a;
+var types = /* @__PURE__ */ new Set(["!", "?", "+", "*", "@"]);
+var isExtglobType = (c) => types.has(c);
+var isExtglobAST = (c) => isExtglobType(c.type);
+var adoptionMap = /* @__PURE__ */ new Map([
+  ["!", ["@"]],
+  ["?", ["?", "@"]],
+  ["@", ["@"]],
+  ["*", ["*", "+", "?", "@"]],
+  ["+", ["+", "@"]]
+]);
+var adoptionWithSpaceMap = /* @__PURE__ */ new Map([
+  ["!", ["?"]],
+  ["@", ["?"]],
+  ["+", ["?", "*"]]
+]);
+var adoptionAnyMap = /* @__PURE__ */ new Map([
+  ["!", ["?", "@"]],
+  ["?", ["?", "@"]],
+  ["@", ["?", "@"]],
+  ["*", ["*", "+", "?", "@"]],
+  ["+", ["+", "@", "?", "*"]]
+]);
+var usurpMap = /* @__PURE__ */ new Map([
+  ["!", /* @__PURE__ */ new Map([["!", "@"]])],
+  ["?", /* @__PURE__ */ new Map([["*", "*"], ["+", "*"]])],
+  ["@", /* @__PURE__ */ new Map([["!", "!"], ["?", "?"], ["@", "@"], ["*", "*"], ["+", "+"]])],
+  ["+", /* @__PURE__ */ new Map([["?", "*"], ["*", "*"]])]
+]);
+var startNoTraversal = "(?!(?:^|/)\\.\\.?(?:$|/))";
+var startNoDot = "(?!\\.)";
+var addPatternStart = /* @__PURE__ */ new Set(["[", "."]);
+var justDots = /* @__PURE__ */ new Set(["..", "."]);
+var reSpecials = new Set("().*{}+?[]^$\\!");
+var regExpEscape = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+var qmark = "[^/]";
+var star = qmark + "*?";
+var starNoEmpty = qmark + "+?";
+var AST = class {
+  type;
+  #root;
+  #hasMagic;
+  #uflag = false;
+  #parts = [];
+  #parent;
+  #parentIndex;
+  #negs;
+  #filledNegs = false;
+  #options;
+  #toString;
+  // set to true if it's an extglob with no children
+  // (which really means one child of '')
+  #emptyExt = false;
+  constructor(type, parent, options = {}) {
+    this.type = type;
+    if (type)
+      this.#hasMagic = true;
+    this.#parent = parent;
+    this.#root = this.#parent ? this.#parent.#root : this;
+    this.#options = this.#root === this ? options : this.#root.#options;
+    this.#negs = this.#root === this ? [] : this.#root.#negs;
+    if (type === "!" && !this.#root.#filledNegs)
+      this.#negs.push(this);
+    this.#parentIndex = this.#parent ? this.#parent.#parts.length : 0;
+  }
+  get hasMagic() {
+    if (this.#hasMagic !== void 0)
+      return this.#hasMagic;
+    for (const p of this.#parts) {
+      if (typeof p === "string")
+        continue;
+      if (p.type || p.hasMagic)
+        return this.#hasMagic = true;
     }
-    return [];
+    return this.#hasMagic;
   }
-}
-async function writeServerRegistry(servers) {
-  await mkdir5(getRegistryDir(), { recursive: true });
-  const data = { version: 1, servers };
-  const content = JSON.stringify(data, null, 2);
-  await writeFile3(REGISTRY_PATH, content, "utf-8");
-  const verification = await readFile6(REGISTRY_PATH, "utf-8");
-  const verified = JSON.parse(verification);
-  if (verified.servers.length !== servers.length) {
-    await writeFile3(REGISTRY_PATH, content, "utf-8");
+  // reconstructs the pattern
+  toString() {
+    if (this.#toString !== void 0)
+      return this.#toString;
+    if (!this.type) {
+      return this.#toString = this.#parts.map((p) => String(p)).join("");
+    } else {
+      return this.#toString = this.type + "(" + this.#parts.map((p) => String(p)).join("|") + ")";
+    }
+  }
+  #fillNegs() {
+    if (this !== this.#root)
+      throw new Error("should only call on root");
+    if (this.#filledNegs)
+      return this;
+    this.toString();
+    this.#filledNegs = true;
+    let n;
+    while (n = this.#negs.pop()) {
+      if (n.type !== "!")
+        continue;
+      let p = n;
+      let pp = p.#parent;
+      while (pp) {
+        for (let i = p.#parentIndex + 1; !pp.type && i < pp.#parts.length; i++) {
+          for (const part of n.#parts) {
+            if (typeof part === "string") {
+              throw new Error("string part in extglob AST??");
+            }
+            part.copyIn(pp.#parts[i]);
+          }
+        }
+        p = pp;
+        pp = p.#parent;
+      }
+    }
+    return this;
   }
-}
-async function registerServer(entry) {
+  push(...parts) {
+    for (const p of parts) {
+      if (p === "")
+        continue;
+      if (typeof p !== "string" && !(p instanceof _a && p.#parent === this)) {
+        throw new Error("invalid part: " + p);
+      }
+      this.#parts.push(p);
+    }
+  }
+  toJSON() {
+    const ret = this.type === null ? this.#parts.slice().map((p) => typeof p === "string" ? p : p.toJSON()) : [this.type, ...this.#parts.map((p) => p.toJSON())];
+    if (this.isStart() && !this.type)
+      ret.unshift([]);
+    if (this.isEnd() && (this === this.#root || this.#root.#filledNegs && this.#parent?.type === "!")) {
+      ret.push({});
+    }
+    return ret;
+  }
+  isStart() {
+    if (this.#root === this)
+      return true;
+    if (!this.#parent?.isStart())
+      return false;
+    if (this.#parentIndex === 0)
+      return true;
+    const p = this.#parent;
+    for (let i = 0; i < this.#parentIndex; i++) {
+      const pp = p.#parts[i];
+      if (!(pp instanceof _a && pp.type === "!")) {
+        return false;
+      }
+    }
+    return true;
+  }
+  isEnd() {
+    if (this.#root === this)
+      return true;
+    if (this.#parent?.type === "!")
+      return true;
+    if (!this.#parent?.isEnd())
+      return false;
+    if (!this.type)
+      return this.#parent?.isEnd();
+    const pl = this.#parent ? this.#parent.#parts.length : 0;
+    return this.#parentIndex === pl - 1;
+  }
+  copyIn(part) {
+    if (typeof part === "string")
+      this.push(part);
+    else
+      this.push(part.clone(this));
+  }
+  clone(parent) {
+    const c = new _a(this.type, parent);
+    for (const p of this.#parts) {
+      c.copyIn(p);
+    }
+    return c;
+  }
+  static #parseAST(str, ast, pos, opt, extDepth) {
+    const maxDepth = opt.maxExtglobRecursion ?? 2;
+    let escaping = false;
+    let inBrace = false;
+    let braceStart = -1;
+    let braceNeg = false;
+    if (ast.type === null) {
+      let i2 = pos;
+      let acc2 = "";
+      while (i2 < str.length) {
+        const c = str.charAt(i2++);
+        if (escaping || c === "\\") {
+          escaping = !escaping;
+          acc2 += c;
+          continue;
+        }
+        if (inBrace) {
+          if (i2 === braceStart + 1) {
+            if (c === "^" || c === "!") {
+              braceNeg = true;
+            }
+          } else if (c === "]" && !(i2 === braceStart + 2 && braceNeg)) {
+            inBrace = false;
+          }
+          acc2 += c;
+          continue;
+        } else if (c === "[") {
+          inBrace = true;
+          braceStart = i2;
+          braceNeg = false;
+          acc2 += c;
+          continue;
+        }
+        const doRecurse = !opt.noext && isExtglobType(c) && str.charAt(i2) === "(" && extDepth <= maxDepth;
+        if (doRecurse) {
+          ast.push(acc2);
+          acc2 = "";
+          const ext2 = new _a(c, ast);
+          i2 = _a.#parseAST(str, ext2, i2, opt, extDepth + 1);
+          ast.push(ext2);
+          continue;
+        }
+        acc2 += c;
+      }
+      ast.push(acc2);
+      return i2;
+    }
+    let i = pos + 1;
+    let part = new _a(null, ast);
+    const parts = [];
+    let acc = "";
+    while (i < str.length) {
+      const c = str.charAt(i++);
+      if (escaping || c === "\\") {
+        escaping = !escaping;
+        acc += c;
+        continue;
+      }
+      if (inBrace) {
+        if (i === braceStart + 1) {
+          if (c === "^" || c === "!") {
+            braceNeg = true;
+          }
+        } else if (c === "]" && !(i === braceStart + 2 && braceNeg)) {
+          inBrace = false;
+        }
+        acc += c;
+        continue;
+      } else if (c === "[") {
+        inBrace = true;
+        braceStart = i;
+        braceNeg = false;
+        acc += c;
+        continue;
+      }
+      const doRecurse = isExtglobType(c) && str.charAt(i) === "(" && /* c8 ignore start - the maxDepth is sufficient here */
+      (extDepth <= maxDepth || ast && ast.#canAdoptType(c));
+      if (doRecurse) {
+        const depthAdd = ast && ast.#canAdoptType(c) ? 0 : 1;
+        part.push(acc);
+        acc = "";
+        const ext2 = new _a(c, part);
+        part.push(ext2);
+        i = _a.#parseAST(str, ext2, i, opt, extDepth + depthAdd);
+        continue;
+      }
+      if (c === "|") {
+        part.push(acc);
+        acc = "";
+        parts.push(part);
+        part = new _a(null, ast);
+        continue;
+      }
+      if (c === ")") {
+        if (acc === "" && ast.#parts.length === 0) {
+          ast.#emptyExt = true;
+        }
+        part.push(acc);
+        acc = "";
+        ast.push(...parts, part);
+        return i;
+      }
+      acc += c;
+    }
+    ast.type = null;
+    ast.#hasMagic = void 0;
+    ast.#parts = [str.substring(pos - 1)];
+    return i;
+  }
+  #canAdoptWithSpace(child) {
+    return this.#canAdopt(child, adoptionWithSpaceMap);
+  }
+  #canAdopt(child, map = adoptionMap) {
+    if (!child || typeof child !== "object" || child.type !== null || child.#parts.length !== 1 || this.type === null) {
+      return false;
+    }
+    const gc = child.#parts[0];
+    if (!gc || typeof gc !== "object" || gc.type === null) {
+      return false;
+    }
+    return this.#canAdoptType(gc.type, map);
+  }
+  #canAdoptType(c, map = adoptionAnyMap) {
+    return !!map.get(this.type)?.includes(c);
+  }
+  #adoptWithSpace(child, index) {
+    const gc = child.#parts[0];
+    const blank = new _a(null, gc, this.options);
+    blank.#parts.push("");
+    gc.push(blank);
+    this.#adopt(child, index);
+  }
+  #adopt(child, index) {
+    const gc = child.#parts[0];
+    this.#parts.splice(index, 1, ...gc.#parts);
+    for (const p of gc.#parts) {
+      if (typeof p === "object")
+        p.#parent = this;
+    }
+    this.#toString = void 0;
+  }
+  #canUsurpType(c) {
+    const m = usurpMap.get(this.type);
+    return !!m?.has(c);
+  }
+  #canUsurp(child) {
+    if (!child || typeof child !== "object" || child.type !== null || child.#parts.length !== 1 || this.type === null || this.#parts.length !== 1) {
+      return false;
+    }
+    const gc = child.#parts[0];
+    if (!gc || typeof gc !== "object" || gc.type === null) {
+      return false;
+    }
+    return this.#canUsurpType(gc.type);
+  }
+  #usurp(child) {
+    const m = usurpMap.get(this.type);
+    const gc = child.#parts[0];
+    const nt = m?.get(gc.type);
+    if (!nt)
+      return false;
+    this.#parts = gc.#parts;
+    for (const p of this.#parts) {
+      if (typeof p === "object")
+        p.#parent = this;
+    }
+    this.type = nt;
+    this.#toString = void 0;
+    this.#emptyExt = false;
+  }
+  #flatten() {
+    if (!isExtglobAST(this)) {
+      for (const p of this.#parts) {
+        if (typeof p === "object")
+          p.#flatten();
+      }
+    } else {
+      let iterations = 0;
+      let done = false;
+      do {
+        done = true;
+        for (let i = 0; i < this.#parts.length; i++) {
+          const c = this.#parts[i];
+          if (typeof c === "object") {
+            c.#flatten();
+            if (this.#canAdopt(c)) {
+              done = false;
+              this.#adopt(c, i);
+            } else if (this.#canAdoptWithSpace(c)) {
+              done = false;
+              this.#adoptWithSpace(c, i);
+            } else if (this.#canUsurp(c)) {
+              done = false;
+              this.#usurp(c);
+            }
+          }
+        }
+      } while (!done && ++iterations < 10);
+    }
+    this.#toString = void 0;
+  }
+  static fromGlob(pattern, options = {}) {
+    const ast = new _a(null, void 0, options);
+    _a.#parseAST(pattern, ast, 0, options, 0);
+    return ast;
+  }
+  // returns the regular expression if there's magic, or the unescaped
+  // string if not.
+  toMMPattern() {
+    if (this !== this.#root)
+      return this.#root.toMMPattern();
+    const glob2 = this.toString();
+    const [re, body, hasMagic, uflag] = this.toRegExpSource();
+    const anyMagic = hasMagic || this.#hasMagic || this.#options.nocase && !this.#options.nocaseMagicOnly && glob2.toUpperCase() !== glob2.toLowerCase();
+    if (!anyMagic) {
+      return body;
+    }
+    const flags = (this.#options.nocase ? "i" : "") + (uflag ? "u" : "");
+    return Object.assign(new RegExp(`^${re}$`, flags), {
+      _src: re,
+      _glob: glob2
+    });
+  }
+  get options() {
+    return this.#options;
+  }
+  // returns the string match, the regexp source, whether there's magic
+  // in the regexp (so a regular expression is required) and whether or
+  // not the uflag is needed for the regular expression (for posix classes)
+  // TODO: instead of injecting the start/end at this point, just return
+  // the BODY of the regexp, along with the start/end portions suitable
+  // for binding the start/end in either a joined full-path makeRe context
+  // (where we bind to (^|/), or a standalone matchPart context (where
+  // we bind to ^, and not /).  Otherwise slashes get duped!
+  //
+  // In part-matching mode, the start is:
+  // - if not isStart: nothing
+  // - if traversal possible, but not allowed: ^(?!\.\.?$)
+  // - if dots allowed or not possible: ^
+  // - if dots possible and not allowed: ^(?!\.)
+  // end is:
+  // - if not isEnd(): nothing
+  // - else: $
+  //
+  // In full-path matching mode, we put the slash at the START of the
+  // pattern, so start is:
+  // - if first pattern: same as part-matching mode
+  // - if not isStart(): nothing
+  // - if traversal possible, but not allowed: /(?!\.\.?(?:$|/))
+  // - if dots allowed or not possible: /
+  // - if dots possible and not allowed: /(?!\.)
+  // end is:
+  // - if last pattern, same as part-matching mode
+  // - else nothing
+  //
+  // Always put the (?:$|/) on negated tails, though, because that has to be
+  // there to bind the end of the negated pattern portion, and it's easier to
+  // just stick it in now rather than try to inject it later in the middle of
+  // the pattern.
+  //
+  // We can just always return the same end, and leave it up to the caller
+  // to know whether it's going to be used joined or in parts.
+  // And, if the start is adjusted slightly, can do the same there:
+  // - if not isStart: nothing
+  // - if traversal possible, but not allowed: (?:/|^)(?!\.\.?$)
+  // - if dots allowed or not possible: (?:/|^)
+  // - if dots possible and not allowed: (?:/|^)(?!\.)
+  //
+  // But it's better to have a simpler binding without a conditional, for
+  // performance, so probably better to return both start options.
+  //
+  // Then the caller just ignores the end if it's not the first pattern,
+  // and the start always gets applied.
+  //
+  // But that's always going to be $ if it's the ending pattern, or nothing,
+  // so the caller can just attach $ at the end of the pattern when building.
+  //
+  // So the todo is:
+  // - better detect what kind of start is needed
+  // - return both flavors of starting pattern
+  // - attach $ at the end of the pattern when creating the actual RegExp
+  //
+  // Ah, but wait, no, that all only applies to the root when the first pattern
+  // is not an extglob. If the first pattern IS an extglob, then we need all
+  // that dot prevention biz to live in the extglob portions, because eg
+  // +(*|.x*) can match .xy but not .yx.
+  //
+  // So, return the two flavors if it's #root and the first child is not an
+  // AST, otherwise leave it to the child AST to handle it, and there,
+  // use the (?:^|/) style of start binding.
+  //
+  // Even simplified further:
+  // - Since the start for a join is eg /(?!\.) and the start for a part
+  // is ^(?!\.), we can just prepend (?!\.) to the pattern (either root
+  // or start or whatever) and prepend ^ or / at the Regexp construction.
+  toRegExpSource(allowDot) {
+    const dot = allowDot ?? !!this.#options.dot;
+    if (this.#root === this) {
+      this.#flatten();
+      this.#fillNegs();
+    }
+    if (!isExtglobAST(this)) {
+      const noEmpty = this.isStart() && this.isEnd();
+      const src = this.#parts.map((p) => {
+        const [re, _, hasMagic, uflag] = typeof p === "string" ? _a.#parseGlob(p, this.#hasMagic, noEmpty) : p.toRegExpSource(allowDot);
+        this.#hasMagic = this.#hasMagic || hasMagic;
+        this.#uflag = this.#uflag || uflag;
+        return re;
+      }).join("");
+      let start2 = "";
+      if (this.isStart()) {
+        if (typeof this.#parts[0] === "string") {
+          const dotTravAllowed = this.#parts.length === 1 && justDots.has(this.#parts[0]);
+          if (!dotTravAllowed) {
+            const aps = addPatternStart;
+            const needNoTrav = (
+              // dots are allowed, and the pattern starts with [ or .
+              dot && aps.has(src.charAt(0)) || // the pattern starts with \., and then [ or .
+              src.startsWith("\\.") && aps.has(src.charAt(2)) || // the pattern starts with \.\., and then [ or .
+              src.startsWith("\\.\\.") && aps.has(src.charAt(4))
+            );
+            const needNoDot = !dot && !allowDot && aps.has(src.charAt(0));
+            start2 = needNoTrav ? startNoTraversal : needNoDot ? startNoDot : "";
+          }
+        }
+      }
+      let end = "";
+      if (this.isEnd() && this.#root.#filledNegs && this.#parent?.type === "!") {
+        end = "(?:$|\\/)";
+      }
+      const final2 = start2 + src + end;
+      return [
+        final2,
+        unescape(src),
+        this.#hasMagic = !!this.#hasMagic,
+        this.#uflag
+      ];
+    }
+    const repeated = this.type === "*" || this.type === "+";
+    const start = this.type === "!" ? "(?:(?!(?:" : "(?:";
+    let body = this.#partsToRegExp(dot);
+    if (this.isStart() && this.isEnd() && !body && this.type !== "!") {
+      const s = this.toString();
+      const me = this;
+      me.#parts = [s];
+      me.type = null;
+      me.#hasMagic = void 0;
+      return [s, unescape(this.toString()), false, false];
+    }
+    let bodyDotAllowed = !repeated || allowDot || dot || !startNoDot ? "" : this.#partsToRegExp(true);
+    if (bodyDotAllowed === body) {
+      bodyDotAllowed = "";
+    }
+    if (bodyDotAllowed) {
+      body = `(?:${body})(?:${bodyDotAllowed})*?`;
+    }
+    let final = "";
+    if (this.type === "!" && this.#emptyExt) {
+      final = (this.isStart() && !dot ? startNoDot : "") + starNoEmpty;
+    } else {
+      const close = this.type === "!" ? (
+        // !() must match something,but !(x) can match ''
+        "))" + (this.isStart() && !dot && !allowDot ? startNoDot : "") + star + ")"
+      ) : this.type === "@" ? ")" : this.type === "?" ? ")?" : this.type === "+" && bodyDotAllowed ? ")" : this.type === "*" && bodyDotAllowed ? `)?` : `)${this.type}`;
+      final = start + body + close;
+    }
+    return [
+      final,
+      unescape(body),
+      this.#hasMagic = !!this.#hasMagic,
+      this.#uflag
+    ];
+  }
+  #partsToRegExp(dot) {
+    return this.#parts.map((p) => {
+      if (typeof p === "string") {
+        throw new Error("string type in extglob ast??");
+      }
+      const [re, _, _hasMagic, uflag] = p.toRegExpSource(dot);
+      this.#uflag = this.#uflag || uflag;
+      return re;
+    }).filter((p) => !(this.isStart() && this.isEnd()) || !!p).join("|");
+  }
+  static #parseGlob(glob2, hasMagic, noEmpty = false) {
+    let escaping = false;
+    let re = "";
+    let uflag = false;
+    let inStar = false;
+    for (let i = 0; i < glob2.length; i++) {
+      const c = glob2.charAt(i);
+      if (escaping) {
+        escaping = false;
+        re += (reSpecials.has(c) ? "\\" : "") + c;
+        inStar = false;
+        continue;
+      }
+      if (c === "\\") {
+        if (i === glob2.length - 1) {
+          re += "\\\\";
+        } else {
+          escaping = true;
+        }
+        continue;
+      }
+      if (c === "[") {
+        const [src, needUflag, consumed, magic] = parseClass(glob2, i);
+        if (consumed) {
+          re += src;
+          uflag = uflag || needUflag;
+          i += consumed - 1;
+          hasMagic = hasMagic || magic;
+          inStar = false;
+          continue;
+        }
+      }
+      if (c === "*") {
+        if (inStar)
+          continue;
+        inStar = true;
+        re += noEmpty && /^[*]+$/.test(glob2) ? starNoEmpty : star;
+        hasMagic = true;
+        continue;
+      } else {
+        inStar = false;
+      }
+      if (c === "?") {
+        re += qmark;
+        hasMagic = true;
+        continue;
+      }
+      re += regExpEscape(c);
+    }
+    return [re, unescape(glob2), !!hasMagic, uflag];
+  }
+};
+_a = AST;
+
+// ../../node_modules/.pnpm/minimatch@9.0.9/node_modules/minimatch/dist/esm/escape.js
+var escape = (s, { windowsPathsNoEscape = false } = {}) => {
+  return windowsPathsNoEscape ? s.replace(/[?*()[\]]/g, "[$&]") : s.replace(/[?*()[\]\\]/g, "\\$&");
+};
+
+// ../../node_modules/.pnpm/minimatch@9.0.9/node_modules/minimatch/dist/esm/index.js
+var minimatch = (p, pattern, options = {}) => {
+  assertValidPattern(pattern);
+  if (!options.nocomment && pattern.charAt(0) === "#") {
+    return false;
+  }
+  return new Minimatch(pattern, options).match(p);
+};
+var starDotExtRE = /^\*+([^+@!?\*\[\(]*)$/;
+var starDotExtTest = (ext2) => (f) => !f.startsWith(".") && f.endsWith(ext2);
+var starDotExtTestDot = (ext2) => (f) => f.endsWith(ext2);
+var starDotExtTestNocase = (ext2) => {
+  ext2 = ext2.toLowerCase();
+  return (f) => !f.startsWith(".") && f.toLowerCase().endsWith(ext2);
+};
+var starDotExtTestNocaseDot = (ext2) => {
+  ext2 = ext2.toLowerCase();
+  return (f) => f.toLowerCase().endsWith(ext2);
+};
+var starDotStarRE = /^\*+\.\*+$/;
+var starDotStarTest = (f) => !f.startsWith(".") && f.includes(".");
+var starDotStarTestDot = (f) => f !== "." && f !== ".." && f.includes(".");
+var dotStarRE = /^\.\*+$/;
+var dotStarTest = (f) => f !== "." && f !== ".." && f.startsWith(".");
+var starRE = /^\*+$/;
+var starTest = (f) => f.length !== 0 && !f.startsWith(".");
+var starTestDot = (f) => f.length !== 0 && f !== "." && f !== "..";
+var qmarksRE = /^\?+([^+@!?\*\[\(]*)?$/;
+var qmarksTestNocase = ([$0, ext2 = ""]) => {
+  const noext = qmarksTestNoExt([$0]);
+  if (!ext2)
+    return noext;
+  ext2 = ext2.toLowerCase();
+  return (f) => noext(f) && f.toLowerCase().endsWith(ext2);
+};
+var qmarksTestNocaseDot = ([$0, ext2 = ""]) => {
+  const noext = qmarksTestNoExtDot([$0]);
+  if (!ext2)
+    return noext;
+  ext2 = ext2.toLowerCase();
+  return (f) => noext(f) && f.toLowerCase().endsWith(ext2);
+};
+var qmarksTestDot = ([$0, ext2 = ""]) => {
+  const noext = qmarksTestNoExtDot([$0]);
+  return !ext2 ? noext : (f) => noext(f) && f.endsWith(ext2);
+};
+var qmarksTest = ([$0, ext2 = ""]) => {
+  const noext = qmarksTestNoExt([$0]);
+  return !ext2 ? noext : (f) => noext(f) && f.endsWith(ext2);
+};
+var qmarksTestNoExt = ([$0]) => {
+  const len = $0.length;
+  return (f) => f.length === len && !f.startsWith(".");
+};
+var qmarksTestNoExtDot = ([$0]) => {
+  const len = $0.length;
+  return (f) => f.length === len && f !== "." && f !== "..";
+};
+var defaultPlatform = typeof process === "object" && process ? typeof process.env === "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix";
+var path3 = {
+  win32: { sep: "\\" },
+  posix: { sep: "/" }
+};
+var sep = defaultPlatform === "win32" ? path3.win32.sep : path3.posix.sep;
+minimatch.sep = sep;
+var GLOBSTAR = /* @__PURE__ */ Symbol("globstar **");
+minimatch.GLOBSTAR = GLOBSTAR;
+var qmark2 = "[^/]";
+var star2 = qmark2 + "*?";
+var twoStarDot = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?";
+var twoStarNoDot = "(?:(?!(?:\\/|^)\\.).)*?";
+var filter = (pattern, options = {}) => (p) => minimatch(p, pattern, options);
+minimatch.filter = filter;
+var ext = (a, b = {}) => Object.assign({}, a, b);
+var defaults = (def) => {
+  if (!def || typeof def !== "object" || !Object.keys(def).length) {
+    return minimatch;
+  }
+  const orig = minimatch;
+  const m = (p, pattern, options = {}) => orig(p, pattern, ext(def, options));
+  return Object.assign(m, {
+    Minimatch: class Minimatch extends orig.Minimatch {
+      constructor(pattern, options = {}) {
+        super(pattern, ext(def, options));
+      }
+      static defaults(options) {
+        return orig.defaults(ext(def, options)).Minimatch;
+      }
+    },
+    AST: class AST extends orig.AST {
+      /* c8 ignore start */
+      constructor(type, parent, options = {}) {
+        super(type, parent, ext(def, options));
+      }
+      /* c8 ignore stop */
+      static fromGlob(pattern, options = {}) {
+        return orig.AST.fromGlob(pattern, ext(def, options));
+      }
+    },
+    unescape: (s, options = {}) => orig.unescape(s, ext(def, options)),
+    escape: (s, options = {}) => orig.escape(s, ext(def, options)),
+    filter: (pattern, options = {}) => orig.filter(pattern, ext(def, options)),
+    defaults: (options) => orig.defaults(ext(def, options)),
+    makeRe: (pattern, options = {}) => orig.makeRe(pattern, ext(def, options)),
+    braceExpand: (pattern, options = {}) => orig.braceExpand(pattern, ext(def, options)),
+    match: (list, pattern, options = {}) => orig.match(list, pattern, ext(def, options)),
+    sep: orig.sep,
+    GLOBSTAR
+  });
+};
+minimatch.defaults = defaults;
+var braceExpand = (pattern, options = {}) => {
+  assertValidPattern(pattern);
+  if (options.nobrace || !/\{(?:(?!\{).)*\}/.test(pattern)) {
+    return [pattern];
+  }
+  return (0, import_brace_expansion.default)(pattern);
+};
+minimatch.braceExpand = braceExpand;
+var makeRe = (pattern, options = {}) => new Minimatch(pattern, options).makeRe();
+minimatch.makeRe = makeRe;
+var match = (list, pattern, options = {}) => {
+  const mm = new Minimatch(pattern, options);
+  list = list.filter((f) => mm.match(f));
+  if (mm.options.nonull && !list.length) {
+    list.push(pattern);
+  }
+  return list;
+};
+minimatch.match = match;
+var globMagic = /[?*]|[+@!]\(.*?\)|\[|\]/;
+var regExpEscape2 = (s) => s.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+var Minimatch = class {
+  options;
+  set;
+  pattern;
+  windowsPathsNoEscape;
+  nonegate;
+  negate;
+  comment;
+  empty;
+  preserveMultipleSlashes;
+  partial;
+  globSet;
+  globParts;
+  nocase;
+  isWindows;
+  platform;
+  windowsNoMagicRoot;
+  maxGlobstarRecursion;
+  regexp;
+  constructor(pattern, options = {}) {
+    assertValidPattern(pattern);
+    options = options || {};
+    this.options = options;
+    this.maxGlobstarRecursion = options.maxGlobstarRecursion ?? 200;
+    this.pattern = pattern;
+    this.platform = options.platform || defaultPlatform;
+    this.isWindows = this.platform === "win32";
+    this.windowsPathsNoEscape = !!options.windowsPathsNoEscape || options.allowWindowsEscape === false;
+    if (this.windowsPathsNoEscape) {
+      this.pattern = this.pattern.replace(/\\/g, "/");
+    }
+    this.preserveMultipleSlashes = !!options.preserveMultipleSlashes;
+    this.regexp = null;
+    this.negate = false;
+    this.nonegate = !!options.nonegate;
+    this.comment = false;
+    this.empty = false;
+    this.partial = !!options.partial;
+    this.nocase = !!this.options.nocase;
+    this.windowsNoMagicRoot = options.windowsNoMagicRoot !== void 0 ? options.windowsNoMagicRoot : !!(this.isWindows && this.nocase);
+    this.globSet = [];
+    this.globParts = [];
+    this.set = [];
+    this.make();
+  }
+  hasMagic() {
+    if (this.options.magicalBraces && this.set.length > 1) {
+      return true;
+    }
+    for (const pattern of this.set) {
+      for (const part of pattern) {
+        if (typeof part !== "string")
+          return true;
+      }
+    }
+    return false;
+  }
+  debug(..._) {
+  }
+  make() {
+    const pattern = this.pattern;
+    const options = this.options;
+    if (!options.nocomment && pattern.charAt(0) === "#") {
+      this.comment = true;
+      return;
+    }
+    if (!pattern) {
+      this.empty = true;
+      return;
+    }
+    this.parseNegate();
+    this.globSet = [...new Set(this.braceExpand())];
+    if (options.debug) {
+      this.debug = (...args) => console.error(...args);
+    }
+    this.debug(this.pattern, this.globSet);
+    const rawGlobParts = this.globSet.map((s) => this.slashSplit(s));
+    this.globParts = this.preprocess(rawGlobParts);
+    this.debug(this.pattern, this.globParts);
+    let set = this.globParts.map((s, _, __) => {
+      if (this.isWindows && this.windowsNoMagicRoot) {
+        const isUNC = s[0] === "" && s[1] === "" && (s[2] === "?" || !globMagic.test(s[2])) && !globMagic.test(s[3]);
+        const isDrive = /^[a-z]:/i.test(s[0]);
+        if (isUNC) {
+          return [...s.slice(0, 4), ...s.slice(4).map((ss) => this.parse(ss))];
+        } else if (isDrive) {
+          return [s[0], ...s.slice(1).map((ss) => this.parse(ss))];
+        }
+      }
+      return s.map((ss) => this.parse(ss));
+    });
+    this.debug(this.pattern, set);
+    this.set = set.filter((s) => s.indexOf(false) === -1);
+    if (this.isWindows) {
+      for (let i = 0; i < this.set.length; i++) {
+        const p = this.set[i];
+        if (p[0] === "" && p[1] === "" && this.globParts[i][2] === "?" && typeof p[3] === "string" && /^[a-z]:$/i.test(p[3])) {
+          p[2] = "?";
+        }
+      }
+    }
+    this.debug(this.pattern, this.set);
+  }
+  // various transforms to equivalent pattern sets that are
+  // faster to process in a filesystem walk.  The goal is to
+  // eliminate what we can, and push all ** patterns as far
+  // to the right as possible, even if it increases the number
+  // of patterns that we have to process.
+  preprocess(globParts) {
+    if (this.options.noglobstar) {
+      for (let i = 0; i < globParts.length; i++) {
+        for (let j = 0; j < globParts[i].length; j++) {
+          if (globParts[i][j] === "**") {
+            globParts[i][j] = "*";
+          }
+        }
+      }
+    }
+    const { optimizationLevel = 1 } = this.options;
+    if (optimizationLevel >= 2) {
+      globParts = this.firstPhasePreProcess(globParts);
+      globParts = this.secondPhasePreProcess(globParts);
+    } else if (optimizationLevel >= 1) {
+      globParts = this.levelOneOptimize(globParts);
+    } else {
+      globParts = this.adjascentGlobstarOptimize(globParts);
+    }
+    return globParts;
+  }
+  // just get rid of adjascent ** portions
+  adjascentGlobstarOptimize(globParts) {
+    return globParts.map((parts) => {
+      let gs = -1;
+      while (-1 !== (gs = parts.indexOf("**", gs + 1))) {
+        let i = gs;
+        while (parts[i + 1] === "**") {
+          i++;
+        }
+        if (i !== gs) {
+          parts.splice(gs, i - gs);
+        }
+      }
+      return parts;
+    });
+  }
+  // get rid of adjascent ** and resolve .. portions
+  levelOneOptimize(globParts) {
+    return globParts.map((parts) => {
+      parts = parts.reduce((set, part) => {
+        const prev = set[set.length - 1];
+        if (part === "**" && prev === "**") {
+          return set;
+        }
+        if (part === "..") {
+          if (prev && prev !== ".." && prev !== "." && prev !== "**") {
+            set.pop();
+            return set;
+          }
+        }
+        set.push(part);
+        return set;
+      }, []);
+      return parts.length === 0 ? [""] : parts;
+    });
+  }
+  levelTwoFileOptimize(parts) {
+    if (!Array.isArray(parts)) {
+      parts = this.slashSplit(parts);
+    }
+    let didSomething = false;
+    do {
+      didSomething = false;
+      if (!this.preserveMultipleSlashes) {
+        for (let i = 1; i < parts.length - 1; i++) {
+          const p = parts[i];
+          if (i === 1 && p === "" && parts[0] === "")
+            continue;
+          if (p === "." || p === "") {
+            didSomething = true;
+            parts.splice(i, 1);
+            i--;
+          }
+        }
+        if (parts[0] === "." && parts.length === 2 && (parts[1] === "." || parts[1] === "")) {
+          didSomething = true;
+          parts.pop();
+        }
+      }
+      let dd = 0;
+      while (-1 !== (dd = parts.indexOf("..", dd + 1))) {
+        const p = parts[dd - 1];
+        if (p && p !== "." && p !== ".." && p !== "**") {
+          didSomething = true;
+          parts.splice(dd - 1, 2);
+          dd -= 2;
+        }
+      }
+    } while (didSomething);
+    return parts.length === 0 ? [""] : parts;
+  }
+  // First phase: single-pattern processing
+  // <pre> is 1 or more portions
+  // <rest> is 1 or more portions
+  // <p> is any portion other than ., .., '', or **
+  // <e> is . or ''
+  //
+  // **/.. is *brutal* for filesystem walking performance, because
+  // it effectively resets the recursive walk each time it occurs,
+  // and ** cannot be reduced out by a .. pattern part like a regexp
+  // or most strings (other than .., ., and '') can be.
+  //
+  // <pre>/**/../<p>/<p>/<rest> -> {<pre>/../<p>/<p>/<rest>,<pre>/**/<p>/<p>/<rest>}
+  // <pre>/<e>/<rest> -> <pre>/<rest>
+  // <pre>/<p>/../<rest> -> <pre>/<rest>
+  // **/**/<rest> -> **/<rest>
+  //
+  // **/*/<rest> -> */**/<rest> <== not valid because ** doesn't follow
+  // this WOULD be allowed if ** did follow symlinks, or * didn't
+  firstPhasePreProcess(globParts) {
+    let didSomething = false;
+    do {
+      didSomething = false;
+      for (let parts of globParts) {
+        let gs = -1;
+        while (-1 !== (gs = parts.indexOf("**", gs + 1))) {
+          let gss = gs;
+          while (parts[gss + 1] === "**") {
+            gss++;
+          }
+          if (gss > gs) {
+            parts.splice(gs + 1, gss - gs);
+          }
+          let next = parts[gs + 1];
+          const p = parts[gs + 2];
+          const p2 = parts[gs + 3];
+          if (next !== "..")
+            continue;
+          if (!p || p === "." || p === ".." || !p2 || p2 === "." || p2 === "..") {
+            continue;
+          }
+          didSomething = true;
+          parts.splice(gs, 1);
+          const other = parts.slice(0);
+          other[gs] = "**";
+          globParts.push(other);
+          gs--;
+        }
+        if (!this.preserveMultipleSlashes) {
+          for (let i = 1; i < parts.length - 1; i++) {
+            const p = parts[i];
+            if (i === 1 && p === "" && parts[0] === "")
+              continue;
+            if (p === "." || p === "") {
+              didSomething = true;
+              parts.splice(i, 1);
+              i--;
+            }
+          }
+          if (parts[0] === "." && parts.length === 2 && (parts[1] === "." || parts[1] === "")) {
+            didSomething = true;
+            parts.pop();
+          }
+        }
+        let dd = 0;
+        while (-1 !== (dd = parts.indexOf("..", dd + 1))) {
+          const p = parts[dd - 1];
+          if (p && p !== "." && p !== ".." && p !== "**") {
+            didSomething = true;
+            const needDot = dd === 1 && parts[dd + 1] === "**";
+            const splin = needDot ? ["."] : [];
+            parts.splice(dd - 1, 2, ...splin);
+            if (parts.length === 0)
+              parts.push("");
+            dd -= 2;
+          }
+        }
+      }
+    } while (didSomething);
+    return globParts;
+  }
+  // second phase: multi-pattern dedupes
+  // {<pre>/*/<rest>,<pre>/<p>/<rest>} -> <pre>/*/<rest>
+  // {<pre>/<rest>,<pre>/<rest>} -> <pre>/<rest>
+  // {<pre>/**/<rest>,<pre>/<rest>} -> <pre>/**/<rest>
+  //
+  // {<pre>/**/<rest>,<pre>/**/<p>/<rest>} -> <pre>/**/<rest>
+  // ^-- not valid because ** doens't follow symlinks
+  secondPhasePreProcess(globParts) {
+    for (let i = 0; i < globParts.length - 1; i++) {
+      for (let j = i + 1; j < globParts.length; j++) {
+        const matched = this.partsMatch(globParts[i], globParts[j], !this.preserveMultipleSlashes);
+        if (matched) {
+          globParts[i] = [];
+          globParts[j] = matched;
+          break;
+        }
+      }
+    }
+    return globParts.filter((gs) => gs.length);
+  }
+  partsMatch(a, b, emptyGSMatch = false) {
+    let ai = 0;
+    let bi = 0;
+    let result = [];
+    let which = "";
+    while (ai < a.length && bi < b.length) {
+      if (a[ai] === b[bi]) {
+        result.push(which === "b" ? b[bi] : a[ai]);
+        ai++;
+        bi++;
+      } else if (emptyGSMatch && a[ai] === "**" && b[bi] === a[ai + 1]) {
+        result.push(a[ai]);
+        ai++;
+      } else if (emptyGSMatch && b[bi] === "**" && a[ai] === b[bi + 1]) {
+        result.push(b[bi]);
+        bi++;
+      } else if (a[ai] === "*" && b[bi] && (this.options.dot || !b[bi].startsWith(".")) && b[bi] !== "**") {
+        if (which === "b")
+          return false;
+        which = "a";
+        result.push(a[ai]);
+        ai++;
+        bi++;
+      } else if (b[bi] === "*" && a[ai] && (this.options.dot || !a[ai].startsWith(".")) && a[ai] !== "**") {
+        if (which === "a")
+          return false;
+        which = "b";
+        result.push(b[bi]);
+        ai++;
+        bi++;
+      } else {
+        return false;
+      }
+    }
+    return a.length === b.length && result;
+  }
+  parseNegate() {
+    if (this.nonegate)
+      return;
+    const pattern = this.pattern;
+    let negate = false;
+    let negateOffset = 0;
+    for (let i = 0; i < pattern.length && pattern.charAt(i) === "!"; i++) {
+      negate = !negate;
+      negateOffset++;
+    }
+    if (negateOffset)
+      this.pattern = pattern.slice(negateOffset);
+    this.negate = negate;
+  }
+  // set partial to true to test if, for example,
+  // "/a/b" matches the start of "/*/b/*/d"
+  // Partial means, if you run out of file before you run
+  // out of pattern, then that's fine, as long as all
+  // the parts match.
+  matchOne(file, pattern, partial = false) {
+    let fileStartIndex = 0;
+    let patternStartIndex = 0;
+    if (this.isWindows) {
+      const fileDrive = typeof file[0] === "string" && /^[a-z]:$/i.test(file[0]);
+      const fileUNC = !fileDrive && file[0] === "" && file[1] === "" && file[2] === "?" && /^[a-z]:$/i.test(file[3]);
+      const patternDrive = typeof pattern[0] === "string" && /^[a-z]:$/i.test(pattern[0]);
+      const patternUNC = !patternDrive && pattern[0] === "" && pattern[1] === "" && pattern[2] === "?" && typeof pattern[3] === "string" && /^[a-z]:$/i.test(pattern[3]);
+      const fdi = fileUNC ? 3 : fileDrive ? 0 : void 0;
+      const pdi = patternUNC ? 3 : patternDrive ? 0 : void 0;
+      if (typeof fdi === "number" && typeof pdi === "number") {
+        const [fd, pd] = [
+          file[fdi],
+          pattern[pdi]
+        ];
+        if (fd.toLowerCase() === pd.toLowerCase()) {
+          pattern[pdi] = fd;
+          patternStartIndex = pdi;
+          fileStartIndex = fdi;
+        }
+      }
+    }
+    const { optimizationLevel = 1 } = this.options;
+    if (optimizationLevel >= 2) {
+      file = this.levelTwoFileOptimize(file);
+    }
+    if (pattern.includes(GLOBSTAR)) {
+      return this.#matchGlobstar(file, pattern, partial, fileStartIndex, patternStartIndex);
+    }
+    return this.#matchOne(file, pattern, partial, fileStartIndex, patternStartIndex);
+  }
+  #matchGlobstar(file, pattern, partial, fileIndex, patternIndex) {
+    const firstgs = pattern.indexOf(GLOBSTAR, patternIndex);
+    const lastgs = pattern.lastIndexOf(GLOBSTAR);
+    const [head, body, tail] = partial ? [
+      pattern.slice(patternIndex, firstgs),
+      pattern.slice(firstgs + 1),
+      []
+    ] : [
+      pattern.slice(patternIndex, firstgs),
+      pattern.slice(firstgs + 1, lastgs),
+      pattern.slice(lastgs + 1)
+    ];
+    if (head.length) {
+      const fileHead = file.slice(fileIndex, fileIndex + head.length);
+      if (!this.#matchOne(fileHead, head, partial, 0, 0))
+        return false;
+      fileIndex += head.length;
+    }
+    let fileTailMatch = 0;
+    if (tail.length) {
+      if (tail.length + fileIndex > file.length)
+        return false;
+      let tailStart = file.length - tail.length;
+      if (this.#matchOne(file, tail, partial, tailStart, 0)) {
+        fileTailMatch = tail.length;
+      } else {
+        if (file[file.length - 1] !== "" || fileIndex + tail.length === file.length) {
+          return false;
+        }
+        tailStart--;
+        if (!this.#matchOne(file, tail, partial, tailStart, 0))
+          return false;
+        fileTailMatch = tail.length + 1;
+      }
+    }
+    if (!body.length) {
+      let sawSome = !!fileTailMatch;
+      for (let i2 = fileIndex; i2 < file.length - fileTailMatch; i2++) {
+        const f = String(file[i2]);
+        sawSome = true;
+        if (f === "." || f === ".." || !this.options.dot && f.startsWith(".")) {
+          return false;
+        }
+      }
+      return partial || sawSome;
+    }
+    const bodySegments = [[[], 0]];
+    let currentBody = bodySegments[0];
+    let nonGsParts = 0;
+    const nonGsPartsSums = [0];
+    for (const b of body) {
+      if (b === GLOBSTAR) {
+        nonGsPartsSums.push(nonGsParts);
+        currentBody = [[], 0];
+        bodySegments.push(currentBody);
+      } else {
+        currentBody[0].push(b);
+        nonGsParts++;
+      }
+    }
+    let i = bodySegments.length - 1;
+    const fileLength = file.length - fileTailMatch;
+    for (const b of bodySegments) {
+      b[1] = fileLength - (nonGsPartsSums[i--] + b[0].length);
+    }
+    return !!this.#matchGlobStarBodySections(file, bodySegments, fileIndex, 0, partial, 0, !!fileTailMatch);
+  }
+  #matchGlobStarBodySections(file, bodySegments, fileIndex, bodyIndex, partial, globStarDepth, sawTail) {
+    const bs = bodySegments[bodyIndex];
+    if (!bs) {
+      for (let i = fileIndex; i < file.length; i++) {
+        sawTail = true;
+        const f = file[i];
+        if (f === "." || f === ".." || !this.options.dot && f.startsWith(".")) {
+          return false;
+        }
+      }
+      return sawTail;
+    }
+    const [body, after] = bs;
+    while (fileIndex <= after) {
+      const m = this.#matchOne(file.slice(0, fileIndex + body.length), body, partial, fileIndex, 0);
+      if (m && globStarDepth < this.maxGlobstarRecursion) {
+        const sub = this.#matchGlobStarBodySections(file, bodySegments, fileIndex + body.length, bodyIndex + 1, partial, globStarDepth + 1, sawTail);
+        if (sub !== false)
+          return sub;
+      }
+      const f = file[fileIndex];
+      if (f === "." || f === ".." || !this.options.dot && f.startsWith(".")) {
+        return false;
+      }
+      fileIndex++;
+    }
+    return partial || null;
+  }
+  #matchOne(file, pattern, partial, fileIndex, patternIndex) {
+    let fi;
+    let pi;
+    let pl;
+    let fl;
+    for (fi = fileIndex, pi = patternIndex, fl = file.length, pl = pattern.length; fi < fl && pi < pl; fi++, pi++) {
+      this.debug("matchOne loop");
+      let p = pattern[pi];
+      let f = file[fi];
+      this.debug(pattern, p, f);
+      if (p === false || p === GLOBSTAR)
+        return false;
+      let hit;
+      if (typeof p === "string") {
+        hit = f === p;
+        this.debug("string match", p, f, hit);
+      } else {
+        hit = p.test(f);
+        this.debug("pattern match", p, f, hit);
+      }
+      if (!hit)
+        return false;
+    }
+    if (fi === fl && pi === pl) {
+      return true;
+    } else if (fi === fl) {
+      return partial;
+    } else if (pi === pl) {
+      return fi === fl - 1 && file[fi] === "";
+    } else {
+      throw new Error("wtf?");
+    }
+  }
+  braceExpand() {
+    return braceExpand(this.pattern, this.options);
+  }
+  parse(pattern) {
+    assertValidPattern(pattern);
+    const options = this.options;
+    if (pattern === "**")
+      return GLOBSTAR;
+    if (pattern === "")
+      return "";
+    let m;
+    let fastTest = null;
+    if (m = pattern.match(starRE)) {
+      fastTest = options.dot ? starTestDot : starTest;
+    } else if (m = pattern.match(starDotExtRE)) {
+      fastTest = (options.nocase ? options.dot ? starDotExtTestNocaseDot : starDotExtTestNocase : options.dot ? starDotExtTestDot : starDotExtTest)(m[1]);
+    } else if (m = pattern.match(qmarksRE)) {
+      fastTest = (options.nocase ? options.dot ? qmarksTestNocaseDot : qmarksTestNocase : options.dot ? qmarksTestDot : qmarksTest)(m);
+    } else if (m = pattern.match(starDotStarRE)) {
+      fastTest = options.dot ? starDotStarTestDot : starDotStarTest;
+    } else if (m = pattern.match(dotStarRE)) {
+      fastTest = dotStarTest;
+    }
+    const re = AST.fromGlob(pattern, this.options).toMMPattern();
+    if (fastTest && typeof re === "object") {
+      Reflect.defineProperty(re, "test", { value: fastTest });
+    }
+    return re;
+  }
+  makeRe() {
+    if (this.regexp || this.regexp === false)
+      return this.regexp;
+    const set = this.set;
+    if (!set.length) {
+      this.regexp = false;
+      return this.regexp;
+    }
+    const options = this.options;
+    const twoStar = options.noglobstar ? star2 : options.dot ? twoStarDot : twoStarNoDot;
+    const flags = new Set(options.nocase ? ["i"] : []);
+    let re = set.map((pattern) => {
+      const pp = pattern.map((p) => {
+        if (p instanceof RegExp) {
+          for (const f of p.flags.split(""))
+            flags.add(f);
+        }
+        return typeof p === "string" ? regExpEscape2(p) : p === GLOBSTAR ? GLOBSTAR : p._src;
+      });
+      pp.forEach((p, i) => {
+        const next = pp[i + 1];
+        const prev = pp[i - 1];
+        if (p !== GLOBSTAR || prev === GLOBSTAR) {
+          return;
+        }
+        if (prev === void 0) {
+          if (next !== void 0 && next !== GLOBSTAR) {
+            pp[i + 1] = "(?:\\/|" + twoStar + "\\/)?" + next;
+          } else {
+            pp[i] = twoStar;
+          }
+        } else if (next === void 0) {
+          pp[i - 1] = prev + "(?:\\/|" + twoStar + ")?";
+        } else if (next !== GLOBSTAR) {
+          pp[i - 1] = prev + "(?:\\/|\\/" + twoStar + "\\/)" + next;
+          pp[i + 1] = GLOBSTAR;
+        }
+      });
+      return pp.filter((p) => p !== GLOBSTAR).join("/");
+    }).join("|");
+    const [open2, close] = set.length > 1 ? ["(?:", ")"] : ["", ""];
+    re = "^" + open2 + re + close + "$";
+    if (this.negate)
+      re = "^(?!" + re + ").+$";
+    try {
+      this.regexp = new RegExp(re, [...flags].join(""));
+    } catch (ex) {
+      this.regexp = false;
+    }
+    return this.regexp;
+  }
+  slashSplit(p) {
+    if (this.preserveMultipleSlashes) {
+      return p.split("/");
+    } else if (this.isWindows && /^\/\/[^\/]+/.test(p)) {
+      return ["", ...p.split(/\/+/)];
+    } else {
+      return p.split(/\/+/);
+    }
+  }
+  match(f, partial = this.partial) {
+    this.debug("match", f, this.pattern);
+    if (this.comment) {
+      return false;
+    }
+    if (this.empty) {
+      return f === "";
+    }
+    if (f === "/" && partial) {
+      return true;
+    }
+    const options = this.options;
+    if (this.isWindows) {
+      f = f.split("\\").join("/");
+    }
+    const ff = this.slashSplit(f);
+    this.debug(this.pattern, "split", ff);
+    const set = this.set;
+    this.debug(this.pattern, "set", set);
+    let filename = ff[ff.length - 1];
+    if (!filename) {
+      for (let i = ff.length - 2; !filename && i >= 0; i--) {
+        filename = ff[i];
+      }
+    }
+    for (let i = 0; i < set.length; i++) {
+      const pattern = set[i];
+      let file = ff;
+      if (options.matchBase && pattern.length === 1) {
+        file = [filename];
+      }
+      const hit = this.matchOne(file, pattern, partial);
+      if (hit) {
+        if (options.flipNegate) {
+          return true;
+        }
+        return !this.negate;
+      }
+    }
+    if (options.flipNegate) {
+      return false;
+    }
+    return this.negate;
+  }
+  static defaults(def) {
+    return minimatch.defaults(def).Minimatch;
+  }
+};
+minimatch.AST = AST;
+minimatch.Minimatch = Minimatch;
+minimatch.escape = escape;
+minimatch.unescape = unescape;
+
+// ../../packages/flint-server/dist/index.js
+import { parse as parseYaml } from "yaml";
+import { existsSync as existsSync10, watch as watch3 } from "fs";
+import { stat as stat22 } from "fs/promises";
+import path22 from "path";
+import { mkdir as mkdir5, readFile as readFile22, writeFile as writeFile3 } from "fs/promises";
+import { homedir as homedir6 } from "os";
+import { join as join11, resolve as resolve7 } from "path";
+import { existsSync as existsSync23 } from "fs";
+import { stat as stat32, readFile as readFile32 } from "fs/promises";
+import path32 from "path";
+import { existsSync as existsSync33 } from "fs";
+import { spawn as spawn22 } from "child_process";
+import { readFile as readFile42 } from "fs/promises";
+import path42 from "path";
+import { readdir as readdir2 } from "fs/promises";
+import path5 from "path";
+import { readdir as readdir22 } from "fs/promises";
+import { join as join23 } from "path";
+import { mkdir as mkdir22, readFile as readFile52, rename as rename2, writeFile as writeFile22, readdir as readdir3 } from "fs/promises";
+import path6 from "path";
+import { randomUUID as randomUUID22 } from "crypto";
+import { writeFile as writeFile32, mkdir as mkdir32, readdir as readdir4, readFile as readFile62, stat as stat42 } from "fs/promises";
+import { join as join33 } from "path";
+var DEFAULT_EVENT_LOG_SIZE = 200;
+function computeRuntimeId(flintPath) {
+  const resolved = path4.resolve(flintPath);
+  return createHash2("sha1").update(resolved).digest("hex").slice(0, 10);
+}
+function createRuntime(options) {
+  return new FlintRuntimeImpl(options);
+}
+var FlintRuntimeImpl = class {
+  id;
+  flintPath;
+  hooksPath;
+  logger;
+  eventLogSize;
+  emitter = new EventEmitter();
+  watcher = null;
+  hooksConfig = { hooks: {} };
+  eventLog = [];
+  frontmatterCache = /* @__PURE__ */ new Map();
+  sessionCache = /* @__PURE__ */ new Map();
+  startedAt = null;
+  constructor(options) {
+    this.flintPath = path4.resolve(options.flintPath);
+    this.hooksPath = options.hooksPath ? path4.resolve(options.hooksPath) : path4.join(this.flintPath, "flint-hooks.toml");
+    this.id = computeRuntimeId(this.flintPath);
+    this.eventLogSize = options.eventLogSize ?? DEFAULT_EVENT_LOG_SIZE;
+    this.logger = options.logger ?? {
+      debug: (...args) => console.debug("[flint-runtime]", ...args),
+      info: (...args) => console.info("[flint-runtime]", ...args),
+      warn: (...args) => console.warn("[flint-runtime]", ...args),
+      error: (...args) => console.error("[flint-runtime]", ...args)
+    };
+  }
+  on(event, handler) {
+    this.emitter.on(event, handler);
+  }
+  off(event, handler) {
+    this.emitter.off(event, handler);
+  }
+  async start() {
+    if (this.watcher) {
+      return;
+    }
+    await this.reloadHooks();
+    await this.seedCaches();
+    const relativeHooksPath = path4.relative(this.flintPath, this.hooksPath);
+    const watchPatterns = [
+      "Mesh/**/*.md",
+      ".flint/sessions/*.json",
+      relativeHooksPath || "flint-hooks.toml"
+    ];
+    this.watcher = chokidar.watch(watchPatterns, {
+      cwd: this.flintPath,
+      ignoreInitial: true,
+      awaitWriteFinish: {
+        stabilityThreshold: 200,
+        pollInterval: 50
+      }
+    });
+    this.watcher.on("add", (filePath) => this.handleWatchEvent("add", filePath));
+    this.watcher.on("change", (filePath) => this.handleWatchEvent("change", filePath));
+    this.watcher.on("unlink", (filePath) => this.handleWatchEvent("unlink", filePath));
+    this.startedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await this.emitEvent("RuntimeStart", {
+      startedAt: this.startedAt
+    });
+  }
+  async stop() {
+    if (!this.watcher) {
+      return;
+    }
+    await this.emitEvent("RuntimeStop", {
+      stoppedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    await this.watcher.close();
+    this.watcher = null;
+  }
+  async reloadHooks() {
+    this.hooksConfig = await loadHooksConfig(this.hooksPath, this.logger);
+  }
+  getStatus() {
+    return {
+      id: this.id,
+      flintPath: this.flintPath,
+      hooksPath: this.hooksPath,
+      startedAt: this.startedAt,
+      watching: this.watcher !== null,
+      hookCount: countHooks(this.hooksConfig)
+    };
+  }
+  getEventLog() {
+    return [...this.eventLog];
+  }
+  async seedCaches() {
+    const meshFiles = await glob("Mesh/**/*.md", {
+      cwd: this.flintPath,
+      nodir: true
+    });
+    await Promise.all(
+      meshFiles.map(async (filePath) => {
+        const snapshot = await this.readFrontmatterSnapshot(filePath);
+        if (snapshot) {
+          this.frontmatterCache.set(filePath, snapshot);
+        }
+      })
+    );
+    const sessionFiles = await glob(".flint/sessions/*.json", {
+      cwd: this.flintPath,
+      nodir: true
+    });
+    await Promise.all(
+      sessionFiles.map(async (filePath) => {
+        const snapshot = await this.readSessionSnapshot(filePath);
+        if (snapshot) {
+          const sessionId = path4.basename(filePath, ".json");
+          this.sessionCache.set(sessionId, snapshot);
+        }
+      })
+    );
+  }
+  async handleWatchEvent(event, filePath) {
+    const normalized = normalizePath(filePath);
+    if (normalized === normalizePath(path4.relative(this.flintPath, this.hooksPath))) {
+      if (event === "change") {
+        this.logger.info?.("Reloading hooks config");
+        await this.reloadHooks();
+      }
+      return;
+    }
+    if (normalized.startsWith("Mesh/")) {
+      if (event === "unlink") {
+        this.frontmatterCache.delete(normalized);
+        return;
+      }
+      await this.handleMeshFileChange(normalized);
+      return;
+    }
+    if (normalized.startsWith(".flint/sessions/")) {
+      if (event === "unlink") {
+        const sessionId = path4.basename(normalized, ".json");
+        this.sessionCache.delete(sessionId);
+        return;
+      }
+      await this.handleSessionFileChange(normalized);
+      return;
+    }
+  }
+  async handleMeshFileChange(relativePath) {
+    const snapshot = await this.readFrontmatterSnapshot(relativePath);
+    if (!snapshot) {
+      return;
+    }
+    const previous = this.frontmatterCache.get(relativePath);
+    this.frontmatterCache.set(relativePath, snapshot);
+    await this.emitEvent("FileChanged", {
+      path: relativePath,
+      absolutePath: path4.join(this.flintPath, relativePath),
+      frontmatter: snapshot,
+      previousFrontmatter: previous ?? null
+    });
+    if (!previous) {
+      return;
+    }
+    if (previous.status !== snapshot.status) {
+      await this.emitEvent("StatusChanged", {
+        path: relativePath,
+        absolutePath: path4.join(this.flintPath, relativePath),
+        field: "status",
+        from: previous.status ?? null,
+        to: snapshot.status ?? null,
+        tags: snapshot.tags
+      });
+    }
+    const addedTags = snapshot.tags.filter((tag) => !previous.tags.includes(tag));
+    const removedTags = previous.tags.filter((tag) => !snapshot.tags.includes(tag));
+    for (const tag of addedTags) {
+      await this.emitEvent("TagAdded", {
+        path: relativePath,
+        absolutePath: path4.join(this.flintPath, relativePath),
+        tag,
+        tags: snapshot.tags
+      });
+    }
+    for (const tag of removedTags) {
+      await this.emitEvent("TagRemoved", {
+        path: relativePath,
+        absolutePath: path4.join(this.flintPath, relativePath),
+        tag,
+        tags: snapshot.tags
+      });
+    }
+  }
+  async handleSessionFileChange(relativePath) {
+    const snapshot = await this.readSessionSnapshot(relativePath);
+    if (!snapshot) {
+      return;
+    }
+    const sessionId = path4.basename(relativePath, ".json");
+    const previous = this.sessionCache.get(sessionId);
+    this.sessionCache.set(sessionId, snapshot);
+    if (!previous && snapshot.status === "active") {
+      await this.emitEvent("AgentStart", {
+        sessionId,
+        status: snapshot.status,
+        model: snapshot.model,
+        goal: snapshot.goal
+      });
+      return;
+    }
+    if (previous?.status !== snapshot.status) {
+      if (snapshot.status === "active") {
+        await this.emitEvent("AgentStart", {
+          sessionId,
+          status: snapshot.status,
+          model: snapshot.model,
+          goal: snapshot.goal
+        });
+      } else if (snapshot.status) {
+        await this.emitEvent("AgentComplete", {
+          sessionId,
+          status: snapshot.status,
+          model: snapshot.model,
+          goal: snapshot.goal
+        });
+      }
+    }
+  }
+  async emitEvent(type, payload) {
+    const event = {
+      id: randomUUID3(),
+      type,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      payload
+    };
+    this.eventLog.push(event);
+    if (this.eventLog.length > this.eventLogSize) {
+      this.eventLog.shift();
+    }
+    this.emitter.emit(type, event);
+    await this.runHooks(type, event);
+  }
+  async runHooks(type, event) {
+    const hooks = (this.hooksConfig.hooks ?? {})[type] ?? [];
+    if (!hooks.length) {
+      return;
+    }
+    for (const hook of hooks) {
+      if (!hookMatches(type, hook, event.payload)) {
+        continue;
+      }
+      try {
+        await executeHook({
+          hook,
+          event,
+          flintPath: this.flintPath,
+          logger: this.logger
+        });
+      } catch (error3) {
+        this.logger.error?.("Hook execution failed", error3);
+      }
+    }
+  }
+  async readFrontmatterSnapshot(relativePath) {
+    const absolutePath = path4.join(this.flintPath, relativePath);
+    const content = await safeReadFile(absolutePath);
+    if (!content) {
+      return null;
+    }
+    const { frontmatter } = parseFrontmatter(content);
+    const tags = extractTags(frontmatter);
+    const status = frontmatter?.status ? String(frontmatter.status) : void 0;
+    return { status, tags };
+  }
+  async readSessionSnapshot(relativePath) {
+    const absolutePath = path4.join(this.flintPath, relativePath);
+    const content = await safeReadFile(absolutePath);
+    if (!content) {
+      return null;
+    }
+    try {
+      const parsed = JSON.parse(content);
+      return {
+        status: typeof parsed.status === "string" ? parsed.status : void 0,
+        model: typeof parsed.model === "string" ? parsed.model : void 0,
+        goal: typeof parsed.goal === "string" ? parsed.goal : void 0
+      };
+    } catch {
+      return null;
+    }
+  }
+};
+function normalizePath(filePath) {
+  return filePath.replace(/\\/g, "/");
+}
+async function safeReadFile(filePath) {
+  try {
+    const fileStats = await stat4(filePath);
+    if (!fileStats.isFile()) {
+      return null;
+    }
+    return await readFile6(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+}
+function parseFrontmatter(content) {
+  const match2 = content.match(/^---\n([\s\S]*?)\n---\n?/);
+  if (!match2) {
+    return { frontmatter: null, body: content };
+  }
+  const raw = match2[1] ?? "";
+  let frontmatter = {};
+  try {
+    const parsed = parseYaml(raw);
+    if (parsed && typeof parsed === "object") {
+      frontmatter = parsed;
+    }
+  } catch {
+    frontmatter = {};
+  }
+  const body = content.slice(match2[0].length);
+  return { frontmatter, body };
+}
+function extractTags(frontmatter) {
+  if (!frontmatter || frontmatter.tags === void 0) {
+    return [];
+  }
+  const tags = frontmatter.tags;
+  if (Array.isArray(tags)) {
+    return tags.map((tag) => String(tag));
+  }
+  if (typeof tags === "string") {
+    return [tags];
+  }
+  return [];
+}
+async function loadHooksConfig(hooksPath, logger) {
+  try {
+    const content = await readFile6(hooksPath, "utf-8");
+    const parsed = parse(content);
+    if (parsed && typeof parsed === "object") {
+      return parsed;
+    }
+  } catch (error3) {
+    if (error3.code !== "ENOENT") {
+      logger.warn?.("Failed to read hooks config", error3);
+    }
+  }
+  return { hooks: {} };
+}
+function countHooks(config) {
+  const hooks = config.hooks ?? {};
+  return Object.values(hooks).reduce((count, entries) => count + entries.length, 0);
+}
+function hookMatches(type, hook, payload) {
+  const matcher = hook.matcher;
+  if (!matcher) {
+    return true;
+  }
+  if (typeof matcher === "string") {
+    if (type === "FileChanged") {
+      const targetPath = typeof payload.path === "string" ? payload.path : "";
+      return minimatch(targetPath, matcher, { dot: true });
+    }
+    return true;
+  }
+  if (matcher.tag) {
+    const tags = Array.isArray(payload.tags) ? payload.tags.map(String) : [];
+    if (!tags.includes(matcher.tag)) {
+      return false;
+    }
+  }
+  const fieldValue = typeof payload.field === "string" ? payload.field : void 0;
+  if (matcher.field && matcher.field !== fieldValue) {
+    return false;
+  }
+  const fromValue = typeof payload.from === "string" ? payload.from : void 0;
+  if (matcher.from && matcher.from !== fromValue) {
+    return false;
+  }
+  const toValue = typeof payload.to === "string" ? payload.to : void 0;
+  if (matcher.to && matcher.to !== toValue) {
+    return false;
+  }
+  return true;
+}
+async function executeHook(options) {
+  const { hook, event, flintPath, logger } = options;
+  const command = resolveHookCommand(hook.command, flintPath);
+  logger.debug?.("Running hook", hook.command);
+  await new Promise((resolve22, reject) => {
+    const envPathEntries = [
+      path4.join(flintPath, "node_modules", ".bin"),
+      path4.join(process.cwd(), "node_modules", ".bin"),
+      process.env.PATH
+    ].filter(Boolean);
+    const child = spawn5(command, {
+      cwd: flintPath,
+      env: {
+        ...process.env,
+        PATH: envPathEntries.join(path4.delimiter)
+      },
+      shell: true,
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (data) => {
+      stdout += String(data);
+    });
+    child.stderr?.on("data", (data) => {
+      stderr += String(data);
+    });
+    const timeoutMs = hook.timeout ? hook.timeout * 1e3 : void 0;
+    let timeoutId = null;
+    if (timeoutMs) {
+      timeoutId = setTimeout(() => {
+        child.kill("SIGKILL");
+        reject(new Error(`Hook timed out after ${hook.timeout}s: ${hook.command}`));
+      }, timeoutMs);
+    }
+    child.on("error", (error3) => {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+      reject(error3);
+    });
+    child.on("close", (code) => {
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+      if (code === 0) {
+        if (stdout.trim()) {
+          logger.info?.(`Hook output: ${stdout.trim()}`);
+        }
+        resolve22();
+        return;
+      }
+      if (code === 2) {
+        logger.warn?.(`Hook blocked: ${hook.command}`);
+        if (stderr.trim()) {
+          logger.warn?.(stderr.trim());
+        }
+        resolve22();
+        return;
+      }
+      const error3 = new Error(`Hook failed (${code ?? "unknown"}): ${hook.command}`);
+      if (stderr.trim()) {
+        logger.error?.(stderr.trim());
+      }
+      reject(error3);
+    });
+    child.stdin?.write(JSON.stringify({
+      event,
+      flint: { path: flintPath }
+    }));
+    child.stdin?.end();
+  });
+}
+function resolveHookCommand(command, flintPath) {
+  const trimmed = command.trim();
+  if (!trimmed) {
+    return trimmed;
+  }
+  const parts = trimmed.split(/\s+/);
+  const target = parts[0] ?? "";
+  const rest = parts.slice(1).join(" ");
+  const extension = path4.extname(target);
+  if (!extension) {
+    return trimmed;
+  }
+  const resolvedTarget = path4.isAbsolute(target) ? target : path4.join(flintPath, target);
+  const quotedTarget = quoteIfNeeded(resolvedTarget);
+  const suffix = rest ? ` ${rest}` : "";
+  if (extension === ".ts") {
+    return `tsx ${quotedTarget}${suffix}`;
+  }
+  if (extension === ".py") {
+    return `python3 ${quotedTarget}${suffix}`;
+  }
+  if (extension === ".sh") {
+    return `bash ${quotedTarget}${suffix}`;
+  }
+  return trimmed;
+}
+function quoteIfNeeded(value) {
+  if (value.includes(" ")) {
+    return `"${value.replace(/"/g, '\\"')}"`;
+  }
+  return value;
+}
+function sendApiError(reply, status, error3, message, extra = {}) {
+  return reply.code(status).send({ error: error3, message, ...extra });
+}
+var CONTENT_TYPES = {
+  ".css": "text/css; charset=utf-8",
+  ".html": "text/html; charset=utf-8",
+  ".js": "application/javascript; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".map": "application/json; charset=utf-8",
+  ".mjs": "application/javascript; charset=utf-8",
+  ".png": "image/png",
+  ".svg": "image/svg+xml",
+  ".tsx": "text/plain; charset=utf-8",
+  ".txt": "text/plain; charset=utf-8",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2"
+};
+function contentTypeFor(filePath) {
+  return CONTENT_TYPES[path22.extname(filePath).toLowerCase()] ?? "application/octet-stream";
+}
+function isImmutableAsset(filePath) {
+  return /\.[a-f0-9]{8,}\./i.test(path22.basename(filePath));
+}
+async function resolveFlintPath4(inputPath) {
+  const resolved = path22.resolve(inputPath);
+  const flintToml = path22.join(resolved, "flint.toml");
+  const flintState = path22.join(resolved, ".flint");
+  const hasConfig = await exists3(flintToml);
+  const hasState = await exists3(flintState);
+  if (!hasConfig && !hasState) {
+    throw new Error(`Not a Flint workspace: ${resolved}`);
+  }
+  return resolved;
+}
+async function exists3(targetPath) {
+  try {
+    await stat22(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function toError(error3, fallbackMessage) {
+  if (error3 instanceof Error) {
+    return error3;
+  }
+  return new Error(typeof error3 === "string" ? error3 : fallbackMessage);
+}
+function isUnsupportedRecursiveWatchError(error3) {
+  const code = typeof error3 === "object" && error3 !== null && "code" in error3 ? String(error3.code ?? "") : "";
+  return code === "ERR_FEATURE_UNAVAILABLE_ON_PLATFORM" || code === "ENOSYS" || code === "ENOTSUP";
+}
+function createResilientWatcher({
+  label,
+  targetPath,
+  recursive = false,
+  retryMs = 1e3,
+  onChange
+}) {
+  let watcher = null;
+  let retryTimer = null;
+  let closed = false;
+  const scheduleRestart = () => {
+    if (closed || retryTimer) {
+      return;
+    }
+    retryTimer = setTimeout(() => {
+      retryTimer = null;
+      start();
+    }, retryMs);
+    retryTimer.unref?.();
+  };
+  const handleWatchError = (error3) => {
+    const resolved = toError(error3, `${label} watcher failed`);
+    const unsupported = recursive && isUnsupportedRecursiveWatchError(error3);
+    watcher?.close();
+    watcher = null;
+    if (unsupported) {
+      console.warn(`[flint-server] ${label} watcher disabled: recursive fs.watch is not supported on this platform.`);
+      return;
+    }
+    console.warn(`[flint-server] ${label} watcher error: ${resolved.message}. Retrying.`);
+    scheduleRestart();
+  };
+  const start = () => {
+    if (closed) {
+      return;
+    }
+    if (!existsSync10(targetPath)) {
+      scheduleRestart();
+      return;
+    }
+    try {
+      watcher = watch3(targetPath, { recursive }, (_eventType, filename) => {
+        onChange(filename);
+      });
+      watcher.on("error", handleWatchError);
+    } catch (error3) {
+      handleWatchError(error3);
+    }
+  };
+  start();
+  return {
+    close() {
+      closed = true;
+      if (retryTimer) {
+        clearTimeout(retryTimer);
+        retryTimer = null;
+      }
+      watcher?.close();
+      watcher = null;
+    }
+  };
+}
+var RuntimeManager = class {
+  runtimes = /* @__PURE__ */ new Map();
+  async startRuntime(flintPath) {
+    const resolved = await resolveFlintPath4(flintPath);
+    const runtimeId = computeRuntimeId(resolved);
+    const existing = this.runtimes.get(runtimeId);
+    if (existing) {
+      return existing.getStatus();
+    }
+    const runtime2 = createRuntime({ flintPath: resolved });
+    await runtime2.start();
+    this.runtimes.set(runtimeId, runtime2);
+    return runtime2.getStatus();
+  }
+  listRuntimes() {
+    return Array.from(this.runtimes.values()).map((runtime2) => runtime2.getStatus());
+  }
+  getRuntime(id) {
+    return this.runtimes.get(id);
+  }
+  async stopRuntime(id) {
+    const runtime2 = this.runtimes.get(id);
+    if (!runtime2) {
+      return false;
+    }
+    await runtime2.stop();
+    this.runtimes.delete(id);
+    return true;
+  }
+  async stopAll() {
+    const entries = Array.from(this.runtimes.entries());
+    await Promise.all(entries.map(async ([id, runtime2]) => {
+      await runtime2.stop();
+      this.runtimes.delete(id);
+    }));
+  }
+};
+var REGISTRY_PATH = join11(homedir6(), ".nuucognition", "servers.json");
+function getRegistryDir() {
+  return join11(homedir6(), ".nuucognition");
+}
+async function readServerRegistry() {
+  try {
+    const content = await readFile22(REGISTRY_PATH, "utf-8");
+    const data = JSON.parse(content);
+    return data.servers ?? [];
+  } catch (error3) {
+    if (error3.code === "ENOENT") {
+      return [];
+    }
+    return [];
+  }
+}
+async function writeServerRegistry(servers) {
+  await mkdir5(getRegistryDir(), { recursive: true });
+  const data = { version: 1, servers };
+  const content = JSON.stringify(data, null, 2);
+  await writeFile3(REGISTRY_PATH, content, "utf-8");
+  const verification = await readFile22(REGISTRY_PATH, "utf-8");
+  const verified = JSON.parse(verification);
+  if (verified.servers.length !== servers.length) {
+    await writeFile3(REGISTRY_PATH, content, "utf-8");
+  }
+}
+async function registerServer(entry) {
   const servers = await readServerRegistry();
   const resolvedPath = resolve7(entry.flintPath);
   const filtered = servers.filter((s) => resolve7(s.flintPath) !== resolvedPath);
@@ -11092,26 +13354,39 @@ function registerPlatesRoutes(app, ctx) {
       ...id ? { id } : {}
     });
   }
+  function toPlateSummary(plate) {
+    return {
+      name: plate.manifest.name,
+      title: plate.manifest.title,
+      version: plate.manifest.version ?? "0.1.0",
+      description: plate.manifest.description,
+      icon: plate.manifest.icon,
+      shard: plate.manifest.shard,
+      handles: (plate.manifest.handles ?? []).map((handle) => ({
+        tag: handle.tag,
+        default: handle.default === true
+      })),
+      actions: (plate.manifest.actions ?? []).map((action) => ({
+        id: action.id,
+        label: action.label,
+        description: action.description,
+        icon: action.icon
+      })),
+      built: plate.built,
+      stale: plate.stale,
+      tools: (plate.manifest.tools ?? []).map((tool) => ({
+        name: tool.name,
+        description: tool.description
+      }))
+    };
+  }
   app.get("/api/plates", async (_request, reply) => {
     if (!ctx.flintPath) {
       return sendApiError(reply, 500, "not_found", "No Flint workspace configured");
     }
     try {
       const plates = await listPlates(ctx.flintPath);
-      return plates.map((plate) => ({
-        name: plate.manifest.name,
-        title: plate.manifest.title,
-        version: plate.manifest.version ?? "0.1.0",
-        description: plate.manifest.description,
-        icon: plate.manifest.icon,
-        shard: plate.manifest.shard,
-        built: plate.built,
-        stale: plate.stale,
-        tools: (plate.manifest.tools ?? []).map((tool) => ({
-          name: tool.name,
-          description: tool.description
-        }))
-      }));
+      return plates.map((plate) => toPlateSummary(plate));
     } catch (error3) {
       const message = error3 instanceof Error ? error3.message : String(error3);
       return sendApiError(reply, 500, "validation_error", message);
@@ -11125,20 +13400,7 @@ function registerPlatesRoutes(app, ctx) {
     if (!plate) {
       return sendApiError(reply, 404, "not_found", `Plate "${request.params.name}" was not found`);
     }
-    return {
-      name: plate.manifest.name,
-      title: plate.manifest.title,
-      version: plate.manifest.version ?? "0.1.0",
-      description: plate.manifest.description,
-      icon: plate.manifest.icon,
-      shard: plate.manifest.shard,
-      built: plate.built,
-      stale: plate.stale,
-      tools: (plate.manifest.tools ?? []).map((tool) => ({
-        name: tool.name,
-        description: tool.description
-      }))
-    };
+    return toPlateSummary(plate);
   });
   async function servePlateAsset(plateName, requestedPath, reply) {
     if (!ctx.flintPath) {
@@ -11148,18 +13410,18 @@ function registerPlatesRoutes(app, ctx) {
     if (!plate) {
       return sendApiError(reply, 404, "not_found", `Plate "${plateName}" was not found`);
     }
-    const entryPath = path22.resolve(plate.path, plate.manifest.entry);
-    const distRoot = path22.dirname(entryPath);
-    if (!await stat22(distRoot).catch(() => null)) {
+    const entryPath = path32.resolve(plate.path, plate.manifest.entry);
+    const distRoot = path32.dirname(entryPath);
+    if (!await stat32(distRoot).catch(() => null)) {
       return sendApiError(reply, 404, "plate_not_built", `Plate "${plate.manifest.name}" has not been built`, {
         plate: plate.manifest.name
       });
     }
-    const targetPath = requestedPath && requestedPath.length > 0 ? path22.resolve(distRoot, requestedPath) : entryPath;
-    if (!targetPath.startsWith(distRoot) || !await stat22(targetPath).catch(() => null)) {
+    const targetPath = requestedPath && requestedPath.length > 0 ? path32.resolve(distRoot, requestedPath) : entryPath;
+    if (!targetPath.startsWith(distRoot) || !await stat32(targetPath).catch(() => null)) {
       return sendApiError(reply, 404, "not_found", `Asset "${requestedPath ?? "/"}" was not found`);
     }
-    const content = await readFile22(targetPath);
+    const content = await readFile32(targetPath);
     reply.header("Content-Type", contentTypeFor(targetPath));
     reply.header("Cache-Control", isImmutableAsset(targetPath) ? "public, max-age=31536000, immutable" : "no-store");
     return reply.send(content);
@@ -11237,7 +13499,7 @@ function registerPlatesRoutes(app, ctx) {
         template: request.body.template,
         data: request.body.data
       });
-      const absolutePath = path22.join(ctx.flintPath, artifact.path);
+      const absolutePath = path32.join(ctx.flintPath, artifact.path);
       suppressPath(absolutePath);
       trackArtifactPath(absolutePath);
       broadcastArtifactEvent("artifact.created", artifact);
@@ -11260,7 +13522,7 @@ function registerPlatesRoutes(app, ctx) {
     if (!artifact) {
       return sendApiError(reply, 404, "not_found", `Artifact "${request.params.id}" was not found`);
     }
-    trackArtifactPath(path22.join(ctx.flintPath, artifact.path));
+    trackArtifactPath(path32.join(ctx.flintPath, artifact.path));
     broadcastArtifactEvent("artifact.updated", artifact);
     return artifact;
   });
@@ -11302,7 +13564,7 @@ function registerPlatesRoutes(app, ctx) {
         return sendApiError(reply, 404, "not_found", `Artifact "${request.params.id}" was not found`);
       }
       if (ctx.flintPath) {
-        const newPath = path22.join(ctx.flintPath, result.artifact.path);
+        const newPath = path32.join(ctx.flintPath, result.artifact.path);
         suppressPath(newPath);
         trackArtifactPath(newPath);
       }
@@ -11361,13 +13623,13 @@ function registerPlatesRoutes(app, ctx) {
   const fileDebounceTimers = /* @__PURE__ */ new Map();
   const SKIP_DIRS = /* @__PURE__ */ new Set(["Agents", "Archive", "node_modules", ".git"]);
   function shouldSkipPath(relativePath) {
-    const parts = relativePath.split(path22.sep);
+    const parts = relativePath.split(path32.sep);
     return parts.some((p) => SKIP_DIRS.has(p));
   }
   const handleFileChange = (baseDir, filename) => {
     if (!filename || !ctx.flintPath) return;
     if (!filename.endsWith(".md")) return;
-    const absolutePath = path22.join(baseDir, filename);
+    const absolutePath = path32.join(baseDir, filename);
     if (shouldSkipPath(filename)) return;
     if (suppressedPaths.has(absolutePath)) return;
     const existing = fileDebounceTimers.get(absolutePath);
@@ -11383,7 +13645,7 @@ function registerPlatesRoutes(app, ctx) {
           trackArtifactPath(absolutePath);
           broadcastArtifactEvent(event, artifact);
         } else {
-          const relPath = path22.relative(ctx.flintPath, absolutePath).replace(/\\/g, "/");
+          const relPath = path32.relative(ctx.flintPath, absolutePath).replace(/\\/g, "/");
           untrackArtifactPath(absolutePath);
           broadcastArtifactDeletion(relPath);
         }
@@ -11392,11 +13654,11 @@ function registerPlatesRoutes(app, ctx) {
     }, 50));
   };
   if (ctx.flintPath) {
-    const meshDir = path22.join(ctx.flintPath, "Mesh");
-    const shardsDir = path22.join(ctx.flintPath, "Shards");
+    const meshDir = path32.join(ctx.flintPath, "Mesh");
+    const shardsDir = path32.join(ctx.flintPath, "Shards");
     void queryArtifacts(ctx.flintPath, { includeShards: true, limit: 1e4 }).then((result) => {
       for (const artifact of result.items) {
-        trackArtifactPath(path22.join(ctx.flintPath, artifact.path));
+        trackArtifactPath(path32.join(ctx.flintPath, artifact.path));
       }
     }).catch(() => {
     });
@@ -11522,7 +13784,7 @@ async function readSessionTranscript(session, cwd) {
   if (!transcriptPath) {
     return { entries: [], turns: [], usage: null };
   }
-  const content = await readFile32(transcriptPath, "utf-8").catch(() => null);
+  const content = await readFile42(transcriptPath, "utf-8").catch(() => null);
   if (content == null) {
     return { entries: [], turns: [], usage: null };
   }
@@ -11817,7 +14079,7 @@ function registerOrbhRoutes(app, ctx, options) {
       prompt: prompt6,
       extraArgs: session.runtime === "claude" ? ["--chrome"] : []
     });
-    const child = spawn5(harness.name, args, {
+    const child = spawn22(harness.name, args, {
       cwd: ctx.flintPath,
       detached: true,
       stdio: ["ignore", "ignore", "pipe"],
@@ -12233,7 +14495,7 @@ async function buildFlintIdentity(ctx) {
   ]);
   const sessions = ctx.orbhSessionsDir ? listSessions2(ctx.orbhSessionsDir) : [];
   const activeSessions = sessions.filter((session) => ACTIVE_SESSION_STATUSES.has(session.status)).length;
-  const name = config?.flint?.name ?? registryEntry?.name ?? path32.basename(ctx.flintPath);
+  const name = config?.flint?.name ?? registryEntry?.name ?? path42.basename(ctx.flintPath);
   return {
     name,
     flintId: flintJson?.id ?? null,
@@ -12290,12 +14552,12 @@ function registerWorkspaceRoutes(app, ctx) {
         return;
       }
       for (const entry of entries) {
-        const fullPath = path4.join(dir, entry.name);
+        const fullPath = path5.join(dir, entry.name);
         if (entry.isDirectory()) {
           if (entry.name.startsWith(".") || entry.name === "node_modules" || entry.name === "dist") continue;
           await walk(fullPath);
         } else if (entry.name.endsWith(".md")) {
-          allFiles.push(path4.relative(ctx.flintPath, fullPath));
+          allFiles.push(path5.relative(ctx.flintPath, fullPath));
         }
       }
     }
@@ -12449,16 +14711,16 @@ function registerShardsRoutes(app, ctx) {
       return sendApiError(reply, 500, "no_workspace", "No Flint workspace configured");
     }
     const installed = await getInstalledShardsWithVersions(ctx.flintPath);
-    const match = resolveInstalledShardInfo(installed, request.params.identifier);
-    if (!match) {
+    const match2 = resolveInstalledShardInfo(installed, request.params.identifier);
+    if (!match2) {
       return sendApiError(reply, 404, "not_found", `Shard "${request.params.identifier}" not found`);
     }
     const allResults = await checkShardHealth(ctx.flintPath);
     const shardResults = allResults.filter(
-      (r) => r.check.includes(match.folderName) || r.check.includes(match.name)
+      (r) => r.check.includes(match2.folderName) || r.check.includes(match2.name)
     );
     return {
-      shard: match.name,
+      shard: match2.name,
       results: shardResults.map((r) => ({
         check: r.check,
         status: r.status,
@@ -12492,14 +14754,14 @@ function registerShardsRoutes(app, ctx) {
       return sendApiError(reply, 500, "no_workspace", "No Flint workspace configured");
     }
     const installed = await getInstalledShardsWithVersions(ctx.flintPath);
-    const match = resolveInstalledShardInfo(installed, request.params.identifier);
-    if (!match) {
+    const match2 = resolveInstalledShardInfo(installed, request.params.identifier);
+    if (!match2) {
       return sendApiError(reply, 404, "not_found", `Shard "${request.params.identifier}" not found`);
     }
     try {
-      const results = await healShard(ctx.flintPath, match.folderName);
+      const results = await healShard(ctx.flintPath, match2.folderName);
       return {
-        shard: match.name,
+        shard: match2.name,
         repairs: results.map((r) => ({
           check: r.check,
           status: r.status,
@@ -12533,6 +14795,152 @@ function registerShardsRoutes(app, ctx) {
     }
   });
 }
+function steelDir(flintPath) {
+  return path6.join(flintPath, ".steel");
+}
+function preferencesPath(flintPath) {
+  return path6.join(steelDir(flintPath), "preferences.json");
+}
+function plateStateDir(flintPath, plateName) {
+  return path6.join(steelDir(flintPath), "plates", plateName);
+}
+function plateStatePath(flintPath, plateName, key) {
+  return path6.join(plateStateDir(flintPath, plateName), `${key}.json`);
+}
+function plateBoardsDir(flintPath, plateName) {
+  return path6.join(plateStateDir(flintPath, plateName), "boards");
+}
+function plateBoardPath(flintPath, plateName, board) {
+  return path6.join(plateBoardsDir(flintPath, plateName), `${board}.json`);
+}
+async function readJsonFile(filePath) {
+  try {
+    const raw = await readFile52(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+async function writeJsonFile(filePath, data) {
+  await mkdir22(path6.dirname(filePath), { recursive: true });
+  const tempPath = `${filePath}.tmp-${process.pid}-${Date.now()}`;
+  await writeFile22(tempPath, JSON.stringify(data, null, 2), "utf-8");
+  await rename2(tempPath, filePath);
+}
+function registerSteelRoutes(app, ctx) {
+  app.get("/api/steel/preferences", async (_request, reply) => {
+    if (!ctx.flintPath) {
+      return sendApiError(reply, 500, "no_workspace", "No Flint workspace configured");
+    }
+    const prefs = await readJsonFile(preferencesPath(ctx.flintPath));
+    return prefs ?? {};
+  });
+  app.put("/api/steel/preferences", async (request, reply) => {
+    if (!ctx.flintPath) {
+      return sendApiError(reply, 500, "no_workspace", "No Flint workspace configured");
+    }
+    const body = request.body;
+    await writeJsonFile(preferencesPath(ctx.flintPath), {
+      ...body,
+      updated: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    return { ok: true };
+  });
+  app.get(
+    "/api/steel/plates/:name/state/:key",
+    async (request, reply) => {
+      if (!ctx.flintPath) {
+        return sendApiError(reply, 500, "no_workspace", "No Flint workspace configured");
+      }
+      const { name, key } = request.params;
+      const data = await readJsonFile(plateStatePath(ctx.flintPath, name, key));
+      return data ?? {};
+    }
+  );
+  app.put(
+    "/api/steel/plates/:name/state/:key",
+    async (request, reply) => {
+      if (!ctx.flintPath) {
+        return sendApiError(reply, 500, "no_workspace", "No Flint workspace configured");
+      }
+      const { name, key } = request.params;
+      const body = request.body;
+      await writeJsonFile(plateStatePath(ctx.flintPath, name, key), {
+        ...body,
+        updated: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      return { ok: true };
+    }
+  );
+  app.get(
+    "/api/steel/plates/:name/state",
+    async (request, reply) => {
+      if (!ctx.flintPath) {
+        return sendApiError(reply, 500, "no_workspace", "No Flint workspace configured");
+      }
+      const { name } = request.params;
+      const dir = plateStateDir(ctx.flintPath, name);
+      if (!await exists3(dir)) return {};
+      const entries = {};
+      try {
+        const files = await readdir3(dir, { withFileTypes: true });
+        for (const file of files) {
+          if (!file.isFile() || !file.name.endsWith(".json")) continue;
+          const key = file.name.replace(/\.json$/, "");
+          entries[key] = await readJsonFile(path6.join(dir, file.name));
+        }
+      } catch {
+      }
+      return entries;
+    }
+  );
+  app.get(
+    "/api/steel/plates/:name/boards",
+    async (request, reply) => {
+      if (!ctx.flintPath) {
+        return sendApiError(reply, 500, "no_workspace", "No Flint workspace configured");
+      }
+      const { name } = request.params;
+      const dir = plateBoardsDir(ctx.flintPath, name);
+      if (!await exists3(dir)) return [];
+      try {
+        const files = await readdir3(dir);
+        return files.filter((f) => f.endsWith(".json")).map((f) => f.replace(/\.json$/, ""));
+      } catch {
+        return [];
+      }
+    }
+  );
+  app.get(
+    "/api/steel/plates/:name/boards/:board",
+    async (request, reply) => {
+      if (!ctx.flintPath) {
+        return sendApiError(reply, 500, "no_workspace", "No Flint workspace configured");
+      }
+      const { name, board } = request.params;
+      const data = await readJsonFile(plateBoardPath(ctx.flintPath, name, board));
+      if (!data) {
+        return sendApiError(reply, 404, "not_found", `Board config '${board}' not found for plate '${name}'`);
+      }
+      return data;
+    }
+  );
+  app.put(
+    "/api/steel/plates/:name/boards/:board",
+    async (request, reply) => {
+      if (!ctx.flintPath) {
+        return sendApiError(reply, 500, "no_workspace", "No Flint workspace configured");
+      }
+      const { name, board } = request.params;
+      const body = request.body;
+      await writeJsonFile(plateBoardPath(ctx.flintPath, name, board), {
+        ...body,
+        updated: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      return { ok: true };
+    }
+  );
+}
 var MAX_ENTRIES = 1e3;
 var nextId = 1;
 var buffer = [];
@@ -12542,29 +14950,29 @@ function pushEntry(entry) {
   }
   buffer.push(entry);
 }
-function getLogEntries(filter) {
+function getLogEntries(filter2) {
   let result = buffer;
-  if (filter?.method) {
-    const method = filter.method.toUpperCase();
+  if (filter2?.method) {
+    const method = filter2.method.toUpperCase();
     result = result.filter((entry) => entry.method === method);
   }
-  if (filter?.minStatus != null) {
-    const minStatus = filter.minStatus;
+  if (filter2?.minStatus != null) {
+    const minStatus = filter2.minStatus;
     result = result.filter((entry) => entry.statusCode >= minStatus);
   }
-  if (filter?.maxStatus != null) {
-    const maxStatus = filter.maxStatus;
+  if (filter2?.maxStatus != null) {
+    const maxStatus = filter2.maxStatus;
     result = result.filter((entry) => entry.statusCode <= maxStatus);
   }
-  if (filter?.pathPattern) {
-    const pattern = filter.pathPattern.toLowerCase();
+  if (filter2?.pathPattern) {
+    const pattern = filter2.pathPattern.toLowerCase();
     result = result.filter((entry) => entry.path.toLowerCase().includes(pattern));
   }
-  if (filter?.since) {
-    result = result.filter((entry) => entry.timestamp >= filter.since);
+  if (filter2?.since) {
+    result = result.filter((entry) => entry.timestamp >= filter2.since);
   }
-  if (filter?.limit && filter.limit > 0) {
-    result = result.slice(-filter.limit);
+  if (filter2?.limit && filter2.limit > 0) {
+    result = result.slice(-filter2.limit);
   }
   return result;
 }
@@ -12573,8 +14981,8 @@ var EXCLUDED_PATHS = [
   "/events/stream",
   "/health"
 ];
-function shouldLog(path62) {
-  return !EXCLUDED_PATHS.some((entry) => path62 === entry || path62.startsWith(`${entry}?`));
+function shouldLog(path82) {
+  return !EXCLUDED_PATHS.some((entry) => path82 === entry || path82.startsWith(`${entry}?`));
 }
 var INTERESTING_REQUEST_HEADERS = [
   "accept",
@@ -12621,14 +15029,14 @@ function registerLogsRoutes(app, ctx) {
       return;
     }
     const queryIndex = fullUrl.indexOf("?");
-    const path62 = queryIndex >= 0 ? fullUrl.slice(0, queryIndex) : fullUrl;
+    const path82 = queryIndex >= 0 ? fullUrl.slice(0, queryIndex) : fullUrl;
     const queryString = queryIndex >= 0 ? fullUrl.slice(queryIndex + 1) : null;
     const entry = {
       id: nextId++,
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       method: request.method,
       url: fullUrl,
-      path: path62,
+      path: path82,
       queryString,
       statusCode: reply.statusCode,
       responseTimeMs: Math.round(reply.elapsedTime * 100) / 100,
@@ -12899,7 +15307,7 @@ function registerEventStreamRoutes(app, ctx) {
     const raw = reply.raw;
     raw.writeHead(200, buildSseHeaders(request));
     const subscriber = {
-      id: randomUUID3(),
+      id: randomUUID22(),
       raw,
       channels: new Set(channels),
       sessionIds,
@@ -13020,17 +15428,17 @@ var LiveTranscriptWriter = class {
     const agentsDir = join33(this.flintPath, "Mesh", "Agents");
     let runtimeDirs;
     try {
-      runtimeDirs = await readdir3(agentsDir);
+      runtimeDirs = await readdir4(agentsDir);
     } catch {
       return;
     }
     for (const dir of runtimeDirs) {
       const dirPath = join33(agentsDir, dir);
-      const dirStat = await stat32(dirPath).catch(() => null);
+      const dirStat = await stat42(dirPath).catch(() => null);
       if (!dirStat?.isDirectory()) continue;
       let files;
       try {
-        files = await readdir3(dirPath);
+        files = await readdir4(dirPath);
       } catch {
         continue;
       }
@@ -13039,7 +15447,7 @@ var LiveTranscriptWriter = class {
         const filePath = join33(dirPath, file);
         let content;
         try {
-          content = await readFile42(filePath, "utf-8");
+          content = await readFile62(filePath, "utf-8");
         } catch {
           continue;
         }
@@ -13057,7 +15465,7 @@ var LiveTranscriptWriter = class {
           const finalStatus = session?.status ?? "unknown";
           const statusUpdated = updatedContent.replace(/^status: .+$/m, `status: ${finalStatus}`);
           this.suppress(filePath);
-          await writeFile22(filePath, statusUpdated, "utf-8").catch(() => {
+          await writeFile32(filePath, statusUpdated, "utf-8").catch(() => {
           });
           console.log(`[flint-server] finalized orphaned live transcript: ${file}`);
         }
@@ -13108,12 +15516,12 @@ var LiveTranscriptWriter = class {
     const outputDir = join33(this.flintPath, "Mesh", "Agents", dir);
     const outputPath = join33(outputDir, `${sessionId}.md`);
     try {
-      await mkdir22(outputDir, { recursive: true });
+      await mkdir32(outputDir, { recursive: true });
       const frontmatter = buildLiveFrontmatter(session, live);
       const body = formatTranscriptMarkdown(entries);
       const markdown = frontmatter + body;
       this.suppress(outputPath);
-      await writeFile22(outputPath, markdown, "utf-8");
+      await writeFile32(outputPath, markdown, "utf-8");
       this.writtenPaths.add(outputPath);
     } catch (error3) {
       console.warn(
@@ -13159,9 +15567,9 @@ async function shutdownPairedSteelHost(steelUrl) {
 async function startFlintServer(options = {}) {
   const host = "127.0.0.1";
   const port = options.port ?? 13040;
-  const flintPath = options.flintPath ? path5.resolve(options.flintPath) : void 0;
+  const flintPath = options.flintPath ? path7.resolve(options.flintPath) : void 0;
   const runtimeManager = new RuntimeManager();
-  const orbhSessionsDir = flintPath ? path5.join(flintPath, ".flint", "sessions") : null;
+  const orbhSessionsDir = flintPath ? path7.join(flintPath, ".flint", "sessions") : null;
   const channelRegistry = new ChannelRegistry();
   const app = Fastify({
     logger: options.logger ?? false,
@@ -13185,10 +15593,10 @@ async function startFlintServer(options = {}) {
     suppressedPaths,
     suppressPath
   };
-  const __dirname4 = path5.dirname(fileURLToPath2(import.meta.url));
-  const dashboardDist = path5.resolve(__dirname4, "..", "..", "..", "apps", "flint-dashboard", "dist");
+  const __dirname4 = path7.dirname(fileURLToPath2(import.meta.url));
+  const dashboardDist = path7.resolve(__dirname4, "..", "..", "..", "apps", "flint-dashboard", "dist");
   try {
-    await stat4(dashboardDist);
+    await stat5(dashboardDist);
     await app.register(fastifyStatic, {
       root: dashboardDist,
       prefix: "/",
@@ -13218,6 +15626,7 @@ async function startFlintServer(options = {}) {
   registerIdentityRoutes(app, ctx);
   registerDashboardRoutes(app, ctx);
   registerShardsRoutes(app, ctx);
+  registerSteelRoutes(app, ctx);
   registerWorkspaceRoutes(app, ctx);
   let liveTranscriptWriter = null;
   if (flintPath) {
@@ -13254,7 +15663,7 @@ async function startFlintServer(options = {}) {
         readFlintToml(flintPath)
       ]);
       registryFlintId = flintJson?.id ?? null;
-      registryName = config?.flint?.name ?? path5.basename(flintPath);
+      registryName = config?.flint?.name ?? path7.basename(flintPath);
     } catch {
     }
     await registerServer({
@@ -13275,7 +15684,7 @@ async function startFlintServer(options = {}) {
           console.log(`[flint-server] ${needsBuild.length} plate(s) need building...`);
           for (const plate of needsBuild) {
             try {
-              const nodeModulesExists = await stat4(join43(plate.path, "node_modules")).then(() => true, () => false);
+              const nodeModulesExists = await stat5(join43(plate.path, "node_modules")).then(() => true, () => false);
               if (!nodeModulesExists) {
                 console.log(`[flint-server]   installing deps for ${plate.manifest.title}...`);
                 const installResult = await installPlateDeps(flintPath, plate.manifest.name);
@@ -13413,12 +15822,12 @@ serverCommand.command("dev").description("Start the server in dev mode with auto
   let serverPkgDir;
   try {
     const serverPkgJson = require2.resolve(`${FLINT_SERVER_PACKAGE}/package.json`);
-    serverPkgDir = path6.dirname(serverPkgJson);
+    serverPkgDir = path8.dirname(serverPkgJson);
   } catch {
     console.error(pc25.red("Error: flint-server package not found."));
     process.exit(1);
   }
-  const devEntry = path6.join(serverPkgDir, "src", "dev.ts");
+  const devEntry = path8.join(serverPkgDir, "src", "dev.ts");
   try {
     await stat6(devEntry);
   } catch {
@@ -13536,11 +15945,11 @@ serverCommand.command("list").description("List all running Flint servers from t
 // src/commands/runtime.ts
 import { Command as Command23 } from "commander";
 import pc26 from "picocolors";
-import path7 from "path";
+import path9 from "path";
 var runtimeCommand = new Command23("runtime").description("Manage Flint runtimes");
 runtimeCommand.command("start [flintPath]").description("Start runtime for a Flint").option("--server <url>", "Server URL", "http://127.0.0.1:13040").action(async (flintPath, options) => {
   const serverUrl = options.server;
-  const resolvedPath = flintPath ? path7.resolve(flintPath) : await findFlintRoot(process.cwd());
+  const resolvedPath = flintPath ? path9.resolve(flintPath) : await findFlintRoot(process.cwd());
   if (!resolvedPath) {
     console.error(pc26.red("Error: Not inside a Flint workspace. Provide a path or cd into one."));
     process.exit(1);
@@ -13572,7 +15981,7 @@ runtimeCommand.command("stop [runtimeId]").description("Stop a running runtime")
   let id = runtimeId;
   try {
     if (!id) {
-      const lookupPath = options.path ? path7.resolve(options.path) : await findFlintRoot(process.cwd());
+      const lookupPath = options.path ? path9.resolve(options.path) : await findFlintRoot(process.cwd());
       if (!lookupPath) {
         console.error(pc26.red("Error: Provide a runtime ID or Flint path."));
         process.exit(1);
@@ -13583,10 +15992,10 @@ runtimeCommand.command("stop [runtimeId]").description("Stop a running runtime")
         process.exit(1);
       }
       const payload = await listResponse.json();
-      const match = (payload.runtimes ?? []).find(
+      const match2 = (payload.runtimes ?? []).find(
         (runtime2) => runtime2.flintPath === lookupPath
       );
-      id = match?.id;
+      id = match2?.id;
     }
     if (!id) {
       console.error(pc26.red("Error: Runtime not found."));
@@ -13706,23 +16115,23 @@ async function exportSession(flintPath, sessionId) {
 }
 
 // src/commands/export-codex-session.ts
-import { writeFile as writeFile5, mkdir as mkdir7, readFile as readFile8, readdir as readdir4, stat as stat8 } from "fs/promises";
+import { writeFile as writeFile5, mkdir as mkdir7, readFile as readFile8, readdir as readdir5, stat as stat8 } from "fs/promises";
 import { join as join13 } from "path";
 import { homedir as homedir8 } from "os";
 import pc28 from "picocolors";
 async function findCodexTranscript(sessionId, startedAfter) {
   const sessionsDir = join13(homedir8(), ".codex", "sessions");
   try {
-    const years = await readdir4(sessionsDir);
+    const years = await readdir5(sessionsDir);
     for (const year of years.reverse()) {
       const yearDir = join13(sessionsDir, year);
-      const months = await readdir4(yearDir).catch(() => []);
+      const months = await readdir5(yearDir).catch(() => []);
       for (const month of months.reverse()) {
         const monthDir = join13(yearDir, month);
-        const days = await readdir4(monthDir).catch(() => []);
+        const days = await readdir5(monthDir).catch(() => []);
         for (const day of days.reverse()) {
           const dayDir = join13(monthDir, day);
-          const files = await readdir4(dayDir).catch(() => []);
+          const files = await readdir5(dayDir).catch(() => []);
           for (const file of files) {
             if (!file.endsWith(".jsonl")) continue;
             if (file.includes(sessionId)) {
@@ -14189,8 +16598,8 @@ import { readdirSync as readdirSync6, existsSync as existsSync12, statSync as st
 import { join as join15, basename as basename5 } from "path";
 function extractNumberFromFile(filename, typeName) {
   const regex = new RegExp(`^\\(${typeName}\\)\\s+(\\d+)`, "i");
-  const match = filename.match(regex);
-  return match ? parseInt(match[1], 10) : null;
+  const match2 = filename.match(regex);
+  return match2 ? parseInt(match2[1], 10) : null;
 }
 function collectFilesRecursively(dirPath) {
   const files = [];
@@ -14585,9 +16994,9 @@ import pc35 from "picocolors";
 import { randomUUID as randomUUID5 } from "crypto";
 import { copyFile as copyFile2, mkdir as mkdir8, writeFile as writeFile6, unlink as unlink2, stat as stat10 } from "fs/promises";
 import { join as join17, basename as basename6, resolve as resolve10 } from "path";
-async function exists4(path8) {
+async function exists4(path10) {
   try {
-    await stat10(path8);
+    await stat10(path10);
     return true;
   } catch {
     return false;
@@ -14664,7 +17073,7 @@ var sendCommand = new Command30("send").description("Send files to another Flint
     console.log();
     let sourceFlintName = "Unknown";
     try {
-      const { readFlintToml: readFlintToml3 } = await import("./dist-RGQKIZQW.js");
+      const { readFlintToml: readFlintToml3 } = await import("./dist-EAYA2DAP.js");
       const toml = await readFlintToml3(flintPath);
       if (toml?.flint?.name) {
         sourceFlintName = toml.flint.name;
@@ -14930,8 +17339,8 @@ async function validateEntries(entries) {
       continue;
     }
     seenPaths.set(entry.path, entry);
-    const exists5 = await checkPathExists(entry.path);
-    if (!exists5) {
+    const exists6 = await checkPathExists(entry.path);
+    if (!exists6) {
       issues.push({
         type: "broken_path",
         entry,
@@ -16994,14 +19403,141 @@ orbCommand.command("respond").description("Answer a pending question on a sessio
   }
 });
 
+// src/commands/steel.ts
+import { Command as Command37 } from "commander";
+import pc42 from "picocolors";
+import { readFile as readFile9, readdir as readdir6, rm as rm5 } from "fs/promises";
+import { join as join19 } from "path";
+async function exists5(path10) {
+  try {
+    const { stat: stat11 } = await import("fs/promises");
+    await stat11(path10);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readJsonFile2(filePath) {
+  try {
+    const raw = await readFile9(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+var steelCommand = new Command37("steel").description("Manage Steel UI state (.steel/ directory)").addCommand(
+  new Command37("preferences").description("Show Steel preferences").option("-p, --path <dir>", "Path to flint (default: auto-detect)").option("--reset", "Clear all Steel preferences").action(async (options) => {
+    try {
+      const flintPath = options.path || await findFlintRoot(process.cwd());
+      if (!flintPath) {
+        console.error(pc42.red("Error: Not inside a Flint. Use --path or cd into a Flint."));
+        process.exit(1);
+      }
+      const prefsPath = join19(flintPath, ".steel", "preferences.json");
+      if (options.reset) {
+        if (await exists5(prefsPath)) {
+          await rm5(prefsPath);
+          console.log(pc42.green("Steel preferences cleared."));
+        } else {
+          console.log(pc42.dim("No preferences file found."));
+        }
+        return;
+      }
+      const prefs = await readJsonFile2(prefsPath);
+      if (!prefs) {
+        console.log(pc42.dim("No Steel preferences set."));
+        return;
+      }
+      console.log(JSON.stringify(prefs, null, 2));
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(pc42.red(`Error: ${message}`));
+      process.exit(1);
+    }
+  })
+).addCommand(
+  new Command37("state").description("Show plate state").argument("<plate-name>", "Name of the plate").option("-p, --path <dir>", "Path to flint (default: auto-detect)").option("--reset", "Clear all state for this plate").action(async (plateName, options) => {
+    try {
+      const flintPath = options.path || await findFlintRoot(process.cwd());
+      if (!flintPath) {
+        console.error(pc42.red("Error: Not inside a Flint. Use --path or cd into a Flint."));
+        process.exit(1);
+      }
+      const plateDir = join19(flintPath, ".steel", "plates", plateName);
+      if (options.reset) {
+        if (await exists5(plateDir)) {
+          await rm5(plateDir, { recursive: true });
+          console.log(pc42.green(`State cleared for plate: ${plateName}`));
+        } else {
+          console.log(pc42.dim(`No state found for plate: ${plateName}`));
+        }
+        return;
+      }
+      if (!await exists5(plateDir)) {
+        console.log(pc42.dim(`No state found for plate: ${plateName}`));
+        return;
+      }
+      const files = await readdir6(plateDir, { withFileTypes: true });
+      const stateFiles = files.filter((f) => f.isFile() && f.name.endsWith(".json"));
+      if (stateFiles.length === 0) {
+        console.log(pc42.dim(`No state files for plate: ${plateName}`));
+        return;
+      }
+      console.log(pc42.bold(`Plate state: ${plateName}`));
+      console.log();
+      for (const file of stateFiles) {
+        const key = file.name.replace(/\.json$/, "");
+        const data = await readJsonFile2(join19(plateDir, file.name));
+        console.log(`${pc42.cyan(key)}:`);
+        console.log(JSON.stringify(data, null, 2));
+        console.log();
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(pc42.red(`Error: ${message}`));
+      process.exit(1);
+    }
+  })
+).addCommand(
+  new Command37("boards").description("List board/view configs for a plate").argument("<plate-name>", "Name of the plate").option("-p, --path <dir>", "Path to flint (default: auto-detect)").action(async (plateName, options) => {
+    try {
+      const flintPath = options.path || await findFlintRoot(process.cwd());
+      if (!flintPath) {
+        console.error(pc42.red("Error: Not inside a Flint. Use --path or cd into a Flint."));
+        process.exit(1);
+      }
+      const boardsDir = join19(flintPath, ".steel", "plates", plateName, "boards");
+      if (!await exists5(boardsDir)) {
+        console.log(pc42.dim(`No board configs found for plate: ${plateName}`));
+        return;
+      }
+      const files = await readdir6(boardsDir);
+      const configs = files.filter((f) => f.endsWith(".json"));
+      if (configs.length === 0) {
+        console.log(pc42.dim(`No board configs found for plate: ${plateName}`));
+        return;
+      }
+      console.log(pc42.bold(`Board configs: ${plateName}`));
+      for (const file of configs) {
+        const name = file.replace(/\.json$/, "");
+        console.log(`  ${pc42.cyan(name)}`);
+      }
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(pc42.red(`Error: ${message}`));
+      process.exit(1);
+    }
+  })
+);
+
 // src/index.ts
 var __dirname3 = dirname4(fileURLToPath4(import.meta.url));
-var pkg = JSON.parse(readFileSync11(join19(__dirname3, "..", "package.json"), "utf-8"));
+var pkg = JSON.parse(readFileSync11(join20(__dirname3, "..", "package.json"), "utf-8"));
 var runtime = resolveRuntimeSync({ cliname: "flint" });
 var devAvailable = runtime.mode === "dev";
 var newDir = getConfigDir("flint");
-var oldDir = join19(homedir11(), ".flint");
-var intermediateDir = join19(homedir11(), ".nuucognition", ".flint");
+var oldDir = join20(homedir11(), ".flint");
+var intermediateDir = join20(homedir11(), ".nuucognition", ".flint");
 function migrateDir(sourceDir, label) {
   if (!existsSync15(sourceDir)) return false;
   try {
@@ -17011,15 +19547,15 @@ function migrateDir(sourceDir, label) {
     mkdirSync5(newDir, { recursive: true });
     let migrated = 0;
     for (const entry of filesToMigrate) {
-      const src = join19(sourceDir, entry);
-      const dest = join19(newDir, entry);
+      const src = join20(sourceDir, entry);
+      const dest = join20(newDir, entry);
       if (!existsSync15(dest)) {
         cpSync(src, dest, { recursive: true });
         migrated++;
       }
     }
     if (migrated > 0) {
-      console.log(pc42.yellow(`Migrated ${migrated} item(s) from ${label} to ~/.nuucognition/flint/`));
+      console.log(pc43.yellow(`Migrated ${migrated} item(s) from ${label} to ~/.nuucognition/flint/`));
     }
     return migrated > 0;
   } catch {
@@ -17055,7 +19591,7 @@ var authConfig = {
   defaultEnv: devAvailable ? "dev" : "prod",
   devAvailable
 };
-var program = new Command37();
+var program = new Command38();
 program.name("flint").description("Flint cognitive workspace CLI").version(pkg.version).enablePositionalOptions().option("--verbose", "Show stack traces for errors");
 program.addCommand(createLoginCommand(authConfig));
 program.addCommand(createLogoutCommand(authConfig));
@@ -17095,6 +19631,7 @@ var COMMAND_MAP = [
   { featureId: "code", command: codeCommand },
   { featureId: "tinderbox", command: tinderboxCommand },
   { featureId: "orb", command: orbCommand },
+  { featureId: "steel", command: steelCommand },
   // Dev commands
   { featureId: "runtime", command: runtimeCommand }
 ];
@@ -17109,11 +19646,11 @@ program.on("command:*", (operands) => {
   if (feature && !isFeatureEnabled(FEATURES, cmdName, runtime)) {
     error(`Feature '${cmdName}' requires dev mode.`);
     console.log("");
-    console.log(pc42.dim("Dev features are only available when running the dev binary."));
+    console.log(pc43.dim("Dev features are only available when running the dev binary."));
     process.exit(1);
   }
   error(`Unknown command: ${cmdName}`);
-  console.log(pc42.dim(`Run 'flint --help' for available commands`));
+  console.log(pc43.dim(`Run 'flint --help' for available commands`));
   process.exit(1);
 });
 await program.parseAsync(process.argv);