@nuucognition/flint-cli 0.5.6-dev.4 → 0.5.6-dev.5

package/dist/{chunk-WMXC6KO6.js → chunk-BF3SKNVR.js}

@@ -7,7 +7,7 @@ import {
   registerFlint,
   registerFlintByPath,
   updateFlintEntry
-} from "./chunk-X6OG5PEE.js";
+} from "./chunk-JNIJ5JV6.js";
 import {
   exists,
   runConcurrent
@@ -15,14 +15,15 @@ import {
 import {
   ensureMetadataDirs,
   syncSourceRepoMetadata
-} from "./chunk-M3NSYVYR.js";
+} from "./chunk-RD3WIRZN.js";
+import {
+  syncPlateRepos
+} from "./chunk-JCALNZ4D.js";
 import {
-  addPlateDeclaration,
   addShardToConfig,
   createFlintJson,
   createFlintToml,
   getFlintConfigDir,
-  getPlateDeclarations,
   getShardDeclarations,
   getShardDeclarationsFromConfig,
   getSourceRepositories,
@@ -39,7 +40,7 @@ import {
   toKebabCase,
   writeFlintJson,
   writeFlintToml
-} from "./chunk-CBGQBE6C.js";
+} from "./chunk-LLLVBA4Q.js";
 
 // ../../packages/flint/dist/index.js
 import { mkdir as mkdir2, stat as stat9 } from "fs/promises";
@@ -57,35 +58,29 @@ import { homedir } from "os";
 import { readFile as readFile5, writeFile as writeFile22, mkdir as mkdir32 } from "fs/promises";
 import { readFileSync } from "fs";
 import { join as join52 } from "path";
-import { spawn } from "child_process";
+import { createHash, randomUUID as randomUUID3 } from "crypto";
+import { mkdir as mkdir52, readdir as readdir22, readFile as readFile32, rename as rename5, rm as rm6, writeFile as writeFile42 } from "fs/promises";
+import { basename, dirname as dirname22, join as join72, relative } from "path";
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+import { readFile as readFile22, writeFile as writeFile32, mkdir as mkdir42, access as access22 } from "fs/promises";
+import { join as join62 } from "path";
+import { mkdir as mkdir6, stat as stat42 } from "fs/promises";
+import { join as join82 } from "path";
 import { exec as exec2 } from "child_process";
-import { mkdir as mkdir42, readdir as readdir22, readFile as readFile22, rm as rm6, stat as stat42, writeFile as writeFile32 } from "fs/promises";
-import { basename, join as join62, relative, resolve as resolve2 } from "path";
 import { promisify as promisify2 } from "util";
-import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
-import { createHash, randomUUID as randomUUID3 } from "crypto";
-import { mkdir as mkdir6, readdir as readdir32, readFile as readFile42, rename as rename5, rm as rm22, writeFile as writeFile52 } from "fs/promises";
-import { basename as basename2, dirname as dirname22, join as join82, relative as relative2 } from "path";
-import { parse as parseYaml2, stringify as stringifyYaml2 } from "yaml";
-import { readFile as readFile32, writeFile as writeFile42, mkdir as mkdir52, access as access22 } from "fs/promises";
-import { join as join72 } from "path";
-import { mkdir as mkdir7, stat as stat52 } from "fs/promises";
-import { join as join92 } from "path";
-import { exec as exec3 } from "child_process";
-import { promisify as promisify3 } from "util";
-import { rm as rm32 } from "fs/promises";
+import { rm as rm22 } from "fs/promises";
 import { execFile } from "child_process";
-import { cp as cp3, mkdir as mkdir9, readdir as readdir42, readFile as readFile6, rename as rename22, rm as rm52, stat as stat72, writeFile as writeFile7 } from "fs/promises";
+import { cp as cp3, mkdir as mkdir8, readdir as readdir32, readFile as readFile52, rename as rename22, rm as rm42, stat as stat62, writeFile as writeFile6 } from "fs/promises";
 import { homedir as homedir2 } from "os";
-import { basename as basename3, dirname as dirname3, join as join112, resolve as resolve4 } from "path";
-import { promisify as promisify4 } from "util";
-import { readFile as readFile52, writeFile as writeFile6, mkdir as mkdir8, rm as rm42, stat as stat62 } from "fs/promises";
-import { join as join102 } from "path";
+import { basename as basename2, dirname as dirname3, join as join102, resolve as resolve3 } from "path";
+import { promisify as promisify3 } from "util";
+import { readFile as readFile42, writeFile as writeFile52, mkdir as mkdir7, rm as rm32, stat as stat52 } from "fs/promises";
+import { join as join92 } from "path";
 import { randomUUID as randomUUID22 } from "crypto";
-import { mkdir as mkdir10, readdir as readdir52, copyFile, rm as rm7, readFile as readFile8, writeFile as writeFile8, rmdir as rmdir2 } from "fs/promises";
-import { join as join13, resolve as resolve6, dirname as dirname4 } from "path";
+import { mkdir as mkdir9, readdir as readdir42, copyFile, rm as rm62, readFile as readFile7, writeFile as writeFile7, rmdir as rmdir2 } from "fs/promises";
+import { join as join12, resolve as resolve5, dirname as dirname4 } from "path";
 import { randomUUID as randomUUID32 } from "crypto";
-import { parse as parseYaml4 } from "yaml";
+import { parse as parseYaml3 } from "yaml";
 
 // ../../packages/flint-migrations/dist/index.js
 import { randomUUID as randomUUID2 } from "crypto";
@@ -2356,38 +2351,38 @@ async function runSingleMigration(flintPath, migrationId, options = {}) {
 }
 
 // ../../packages/flint/dist/index.js
-import { join as join12, resolve as resolve5, isAbsolute as isAbsolute2 } from "path";
-import { mkdtemp, rm as rm62 } from "fs/promises";
+import { join as join112, resolve as resolve4, isAbsolute as isAbsolute2 } from "path";
+import { mkdtemp, rm as rm52 } from "fs/promises";
 import { tmpdir } from "os";
-import { exec as exec4 } from "child_process";
-import { promisify as promisify5 } from "util";
-import { parse as parseYaml3 } from "yaml";
-import { readFile as readFile7 } from "fs/promises";
-import { join as join14 } from "path";
-import { readdir as readdir62, mkdir as mkdir11 } from "fs/promises";
-import { writeFile as writeFile9 } from "fs/promises";
+import { exec as exec3 } from "child_process";
+import { promisify as promisify4 } from "util";
+import { parse as parseYaml2 } from "yaml";
+import { readFile as readFile6 } from "fs/promises";
+import { join as join13 } from "path";
+import { readdir as readdir52, mkdir as mkdir10 } from "fs/promises";
+import { writeFile as writeFile8 } from "fs/promises";
 import { execSync } from "child_process";
 import { existsSync } from "fs";
-import { spawn as spawn2 } from "child_process";
-import { readdir as readdir72, access as access3, constants } from "fs/promises";
-import { join as join15, resolve as resolve7 } from "path";
+import { spawn } from "child_process";
+import { readdir as readdir62, access as access3, constants } from "fs/promises";
+import { join as join14, resolve as resolve6 } from "path";
 import { rename as rename32 } from "fs/promises";
-import { basename as basename4, dirname as dirname5, join as join17 } from "path";
-import { exec as exec5 } from "child_process";
-import { promisify as promisify6 } from "util";
-import { readFile as readFile9, writeFile as writeFile10, readdir as readdir82 } from "fs/promises";
-import { join as join16 } from "path";
-import { stat as stat82, mkdir as mkdir12 } from "fs/promises";
-import { readdir as readdir9, readFile as readFile10, mkdir as mkdir13 } from "fs/promises";
-import { join as join18, dirname as dirname6, resolve as resolve8, sep } from "path";
+import { basename as basename3, dirname as dirname5, join as join16 } from "path";
+import { exec as exec4 } from "child_process";
+import { promisify as promisify5 } from "util";
+import { readFile as readFile8, writeFile as writeFile9, readdir as readdir72 } from "fs/promises";
+import { join as join15 } from "path";
+import { stat as stat72, mkdir as mkdir11 } from "fs/promises";
+import { readdir as readdir82, readFile as readFile9, mkdir as mkdir12 } from "fs/promises";
+import { join as join17, dirname as dirname6, resolve as resolve7, sep } from "path";
 import { randomUUID as randomUUID4 } from "crypto";
 import { fileURLToPath } from "url";
 import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync, readdirSync } from "fs";
-import { join as join19 } from "path";
+import { join as join18 } from "path";
 import { randomUUID as randomUUID5 } from "crypto";
 import { watch, watchFile, unwatchFile, statSync, openSync, readSync, closeSync } from "fs";
 import { existsSync as existsSync3 } from "fs";
-import { join as join20 } from "path";
+import { join as join19 } from "path";
 import { homedir as homedir3 } from "os";
 import { existsSync as existsSync4 } from "fs";
 var STANDARD_DIRECTORIES = ["Mesh", "Media", "Shards", "Plates", "Sources", "Exports", "Workspace", "Workspace/Bench"];
@@ -2707,541 +2702,16 @@ async function getOpenApps() {
   const config = await readGlobalConfig();
   return config.open?.apps ?? ["obsidian"];
 }
-var execAsync2 = promisify2(exec2);
-function normalizePlateName(name) {
-  return name.trim().toLowerCase();
-}
-function isSlug(value) {
-  return /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(value);
-}
-async function fileExists2(path) {
-  try {
-    await stat42(path);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function validateManifest(manifest, manifestPath) {
-  if (!manifest || typeof manifest !== "object") {
-    throw new Error(`Invalid plate.yaml at ${manifestPath}`);
-  }
-  const record = manifest;
-  const name = typeof record.name === "string" ? record.name.trim() : "";
-  const title = typeof record.title === "string" ? record.title.trim() : "";
-  const entry = typeof record.entry === "string" ? record.entry.trim() : "";
-  if (!name || !title || !entry) {
-    throw new Error(`plate.yaml is missing required fields (name, title, entry): ${manifestPath}`);
-  }
-  if (!isSlug(name)) {
-    throw new Error(`Invalid plate name "${name}" in ${manifestPath}`);
-  }
-  const tools = Array.isArray(record.tools) ? record.tools.map((tool) => {
-    if (!tool || typeof tool !== "object") {
-      throw new Error(`Invalid tool declaration in ${manifestPath}`);
-    }
-    const toolRecord = tool;
-    const toolName = typeof toolRecord.name === "string" ? toolRecord.name.trim() : "";
-    const command = typeof toolRecord.command === "string" ? toolRecord.command.trim() : "";
-    const description = typeof toolRecord.description === "string" ? toolRecord.description.trim() : "";
-    if (!toolName || !command || !description) {
-      throw new Error(`Tool declaration is missing required fields in ${manifestPath}`);
-    }
-    return { name: toolName, command, description };
-  }) : void 0;
-  const handles = Array.isArray(record.handles) ? record.handles.map((handle) => {
-    if (!handle || typeof handle !== "object") {
-      throw new Error(`Invalid handle declaration in ${manifestPath}`);
-    }
-    const handleRecord = handle;
-    const tag = typeof handleRecord.tag === "string" ? handleRecord.tag.trim() : "";
-    if (!tag) {
-      throw new Error(`Handle declaration is missing required tag in ${manifestPath}`);
-    }
-    return {
-      tag,
-      default: handleRecord.default === true
-    };
-  }) : void 0;
-  const actions = Array.isArray(record.actions) ? record.actions.map((action) => {
-    if (!action || typeof action !== "object") {
-      throw new Error(`Invalid action declaration in ${manifestPath}`);
-    }
-    const actionRecord = action;
-    const id = typeof actionRecord.id === "string" ? actionRecord.id.trim() : "";
-    const label = typeof actionRecord.label === "string" ? actionRecord.label.trim() : "";
-    if (!id || !label) {
-      throw new Error(`Action declaration is missing required fields in ${manifestPath}`);
-    }
-    return {
-      id,
-      label,
-      description: typeof actionRecord.description === "string" ? actionRecord.description : void 0,
-      icon: typeof actionRecord.icon === "string" ? actionRecord.icon : void 0
-    };
-  }) : void 0;
-  return {
-    name,
-    title,
-    entry,
-    version: typeof record.version === "string" ? record.version : void 0,
-    description: typeof record.description === "string" ? record.description : void 0,
-    icon: typeof record.icon === "string" ? record.icon : void 0,
-    shard: typeof record.shard === "string" ? record.shard : void 0,
-    dev: typeof record.dev === "string" ? record.dev : void 0,
-    api: Array.isArray(record.api) ? record.api.filter((value) => typeof value === "string") : void 0,
-    handles,
-    actions,
-    tools
-  };
-}
-async function readPlateManifest(platePath) {
-  const manifestPath = join62(platePath, "plate.yaml");
-  const content = await readFile22(manifestPath, "utf8");
-  return validateManifest(parseYaml(content, { logLevel: "error" }), manifestPath);
-}
-function resolvePlateEntryPath(platePath, manifest) {
-  return resolve2(platePath, manifest.entry);
-}
-var PLATE_SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules", "dist", ".git"]);
-async function getNewestMtime(dir) {
-  let max = 0;
-  try {
-    const entries = await readdir22(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      if (PLATE_SKIP_DIRS.has(entry.name)) continue;
-      const full = join62(dir, entry.name);
-      if (entry.isDirectory()) {
-        const sub = await getNewestMtime(full);
-        if (sub > max) max = sub;
-      } else {
-        const s = await stat42(full);
-        if (s.mtimeMs > max) max = s.mtimeMs;
-      }
-    }
-  } catch {
-  }
-  return max;
-}
-async function checkPlateStale(platePath, manifest) {
-  const entryPath = resolvePlateEntryPath(platePath, manifest);
-  const entryStat = await stat42(entryPath).catch(() => null);
-  if (!entryStat) return false;
-  const sourceMtime = await getNewestMtime(platePath);
-  return sourceMtime > entryStat.mtimeMs;
-}
-async function resolvePlateInfoFromDeclaration(flintPath, declarationName, declarationPath) {
-  const absolutePath = resolve2(flintPath, declarationPath);
-  const manifest = await readPlateManifest(absolutePath);
-  const built = await fileExists2(resolvePlateEntryPath(absolutePath, manifest));
-  const stale = built ? await checkPlateStale(absolutePath, manifest) : false;
-  return {
-    declarationName,
-    directoryName: basename(absolutePath),
-    path: absolutePath,
-    built,
-    stale,
-    manifest
-  };
-}
-async function initPlateRepo(flintPath, plateName, url) {
-  const plate = await getPlate(flintPath, plateName);
-  if (!plate) {
-    throw new Error(`Plate not found: ${plateName}`);
-  }
-  const plateDir = plate.path;
-  const gitDir = join62(plateDir, ".git");
-  const isGitRepo = await fileExists2(gitDir);
-  if (!isGitRepo) {
-    await execAsync2("git init", { cwd: plateDir });
-  }
-  const gitignorePath = join62(plateDir, ".gitignore");
-  if (!await fileExists2(gitignorePath)) {
-    await writeFile32(gitignorePath, "node_modules/\ndist/\n", "utf8");
-  }
-  try {
-    const { stdout: existingRemote } = await execAsync2("git remote get-url origin", { cwd: plateDir });
-    if (existingRemote.trim() !== url) {
-      await execAsync2(`git remote set-url origin "${url}"`, { cwd: plateDir });
-    }
-  } catch {
-    await execAsync2(`git remote add origin "${url}"`, { cwd: plateDir });
-  }
-  await execAsync2("git add .", { cwd: plateDir });
-  let hasChanges = false;
-  try {
-    const { stdout: statusOut } = await execAsync2("git status --porcelain", { cwd: plateDir });
-    hasChanges = statusOut.trim().length > 0;
-  } catch {
-    hasChanges = true;
-  }
-  if (hasChanges) {
-    await execAsync2('git commit -m "Update plate"', { cwd: plateDir });
-  }
-  let pushed = false;
-  try {
-    await execAsync2("git push -u origin main", { cwd: plateDir, timeout: 6e4 });
-    pushed = true;
-  } catch {
-    try {
-      await execAsync2("git push -u origin HEAD", { cwd: plateDir, timeout: 6e4 });
-      pushed = true;
-    } catch {
-    }
-  }
-  return { initialized: !isGitRepo, pushed, platePath: plateDir };
-}
-async function clonePlateFromRepo(flintPath, name, url, targetPath) {
-  const absolutePath = resolve2(flintPath, targetPath);
-  await mkdir42(join62(flintPath, "Plates"), { recursive: true });
-  if (await fileExists2(absolutePath)) {
-    throw new Error(`Plate directory already exists: ${targetPath}`);
-  }
-  try {
-    await execAsync2(`git clone --depth 1 "${url}" "${absolutePath}"`, { timeout: 6e4 });
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw new Error(`Failed to clone plate "${name}": ${message}`);
-  }
-  const gitDir = join62(absolutePath, ".git");
-  try {
-    await rm6(gitDir, { recursive: true, force: true });
-  } catch {
-  }
-  return absolutePath;
-}
-async function updatePlateFromRepo(flintPath, name, url, targetPath) {
-  const absolutePath = resolve2(flintPath, targetPath);
-  if (await fileExists2(absolutePath)) {
-    await rm6(absolutePath, { recursive: true, force: true });
-  }
-  return clonePlateFromRepo(flintPath, name, url, targetPath);
-}
-async function syncPlateRepos(flintPath, declarations) {
-  const results = [];
-  for (const [name, decl] of Object.entries(declarations)) {
-    if (!decl.repo) continue;
-    const absolutePath = resolve2(flintPath, decl.path);
-    const exists2 = await fileExists2(absolutePath);
-    try {
-      if (exists2) {
-        results.push({ name, status: "skipped" });
-      } else {
-        await clonePlateFromRepo(flintPath, name, decl.repo, decl.path);
-        results.push({ name, status: "cloned" });
-      }
-    } catch (err) {
-      results.push({
-        name,
-        status: "error",
-        error: err instanceof Error ? err.message : String(err)
-      });
-    }
-  }
-  return results;
-}
-async function listPlates(flintPath) {
-  const declarations = await getPlateDeclarations(flintPath);
-  const infos = await Promise.all(
-    Object.entries(declarations).map(([name, decl]) => resolvePlateInfoFromDeclaration(flintPath, name, decl.path))
-  );
-  const seenNames = /* @__PURE__ */ new Set();
-  for (const info of infos) {
-    const normalized = normalizePlateName(info.manifest.name);
-    if (seenNames.has(normalized)) {
-      throw new Error(`Duplicate plate manifest name detected: ${info.manifest.name}`);
-    }
-    seenNames.add(normalized);
-  }
-  return infos.sort((left, right) => left.manifest.title.localeCompare(right.manifest.title));
-}
-async function getPlate(flintPath, plateName) {
-  const normalized = normalizePlateName(plateName);
-  const plates = await listPlates(flintPath);
-  return plates.find(
-    (plate) => normalizePlateName(plate.declarationName) === normalized || normalizePlateName(plate.manifest.name) === normalized
-  ) ?? null;
-}
-function renderPlateManifestYaml(slug, title, shard) {
-  const manifest = {
-    name: slug,
-    title,
-    version: "0.1.0",
-    description: `${title} Plate`,
-    entry: "./dist/index.html",
-    dev: "./src/index.tsx",
-    api: ["GET /api/plates", "GET /api/artifacts"]
-  };
-  if (shard) {
-    manifest.shard = shard;
-  }
-  return stringifyYaml(manifest).trimEnd() + "\n";
-}
-async function createPlate(flintPath, displayName, options = {}) {
-  const { proper, slug } = nameFormats(displayName);
-  if (!proper.trim()) {
-    throw new Error("Plate name is required");
-  }
-  const existing = await getPlate(flintPath, slug);
-  if (existing) {
-    throw new Error(`Plate "${slug}" already exists`);
-  }
-  const platePath = join62(flintPath, "Plates", proper);
-  if (await fileExists2(platePath)) {
-    throw new Error(`Plate directory already exists: ${relative(flintPath, platePath)}`);
-  }
-  await mkdir42(join62(platePath, "src"), { recursive: true });
-  await mkdir42(join62(platePath, "tools"), { recursive: true });
-  await writeFile32(join62(platePath, "plate.yaml"), renderPlateManifestYaml(slug, proper, options.shard), "utf8");
-  await writeFile32(join62(platePath, "package.json"), JSON.stringify({
-    name: `@plates/${slug}`,
-    private: true,
-    version: "0.1.0",
-    type: "module",
-    scripts: {
-      dev: "vite",
-      build: "vite build"
-    },
-    dependencies: {
-      "@nuucognition/plate-sdk": "workspace:*",
-      react: "^19.0.0",
-      "react-dom": "^19.0.0"
-    },
-    devDependencies: {
-      "@types/react": "^19.0.0",
-      "@types/react-dom": "^19.0.0",
-      "@vitejs/plugin-react": "^4.0.0",
-      typescript: "^5.0.0",
-      vite: "^6.0.0"
-    }
-  }, null, 2) + "\n", "utf8");
-  await writeFile32(join62(platePath, "tsconfig.json"), JSON.stringify({
-    compilerOptions: {
-      target: "ES2020",
-      useDefineForClassFields: true,
-      lib: ["DOM", "DOM.Iterable", "ES2020"],
-      allowJs: false,
-      skipLibCheck: true,
-      esModuleInterop: true,
-      allowSyntheticDefaultImports: true,
-      strict: true,
-      forceConsistentCasingInFileNames: true,
-      module: "ESNext",
-      moduleResolution: "Bundler",
-      resolveJsonModule: true,
-      isolatedModules: true,
-      noEmit: true,
-      jsx: "react-jsx"
-    },
-    include: ["src"]
-  }, null, 2) + "\n", "utf8");
-  await writeFile32(join62(platePath, "vite.config.ts"), `import { defineConfig } from 'vite';
-import react from '@vitejs/plugin-react';
-
-export default defineConfig({
-  base: '/plates/${slug}/',
-  plugins: [react()],
-  build: {
-    outDir: 'dist',
-  },
-});
-`, "utf8");
-  await writeFile32(join62(platePath, "index.html"), `<!doctype html>
-<html lang="en">
-  <head>
-    <meta charset="UTF-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>${proper}</title>
-  </head>
-  <body>
-    <div id="root"></div>
-    <script type="module" src="/src/index.tsx"></script>
-  </body>
-</html>
-`, "utf8");
-  await writeFile32(join62(platePath, ".gitignore"), "node_modules/\ndist/\n", "utf8");
-  await writeFile32(join62(platePath, "src", "index.tsx"), `import React from 'react';
-import ReactDOM from 'react-dom/client';
-import { getPlateContext } from '@nuucognition/plate-sdk';
-import { App } from './App';
-
-async function bootstrap() {
-  let connected = false;
-
-  try {
-    await getPlateContext();
-    connected = true;
-  } catch {
-    connected = false;
-  }
-
-  ReactDOM.createRoot(document.getElementById('root')!).render(
-    <React.StrictMode>
-      <App connected={connected} />
-    </React.StrictMode>,
-  );
-}
-
-void bootstrap();
-`, "utf8");
-  await writeFile32(join62(platePath, "src", "App.tsx"), `import { usePlateContext } from '@nuucognition/plate-sdk';
-
-export function App({ connected }: { connected: boolean }) {
-  let plateName = '${slug}';
-  let serverUrl = 'Not connected';
-
-  try {
-    const context = usePlateContext();
-    plateName = context.plateName;
-    serverUrl = context.serverUrl;
-  } catch {
-    // Render the disconnected state below.
-  }
-
-  return (
-    <main style={{ fontFamily: 'ui-sans-serif, system-ui, sans-serif', padding: 24 }}>
-      <h1 style={{ margin: 0, fontSize: 28 }}>${proper}</h1>
-      <p style={{ color: '#666', maxWidth: 640 }}>
-        This is the starter Plate scaffold. Replace this view with your interface.
-      </p>
-      <div style={{ border: '1px solid #ddd', borderRadius: 12, padding: 16, marginTop: 24 }}>
-        <div><strong>Plate:</strong> {plateName}</div>
-        <div><strong>SDK:</strong> {connected ? 'Connected to Steel' : 'Standalone preview mode'}</div>
-        <div><strong>Server:</strong> {serverUrl}</div>
-      </div>
-    </main>
-  );
-}
-`, "utf8");
-  await addPlateDeclaration(flintPath, slug, relative(flintPath, platePath), { title: proper });
-  return await getPlate(flintPath, slug);
-}
-function resolveToolCommand(toolPath) {
-  if (toolPath.endsWith(".ts")) {
-    return { command: "npx", args: ["tsx", toolPath] };
-  }
-  if (toolPath.endsWith(".js") || toolPath.endsWith(".mjs")) {
-    return { command: "node", args: [toolPath] };
-  }
-  return { command: toolPath, args: [] };
-}
-function spawnBufferedProcess(command, args, options) {
-  return new Promise((resolvePromise, reject) => {
-    const child = spawn(command, args, {
-      cwd: options.cwd,
-      env: {
-        ...process.env,
-        ...options.env
-      },
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    let stdout = "";
-    let stderr = "";
-    let settled = false;
-    const finish = (result) => {
-      if (settled) {
-        return;
-      }
-      settled = true;
-      resolvePromise(result);
-    };
-    const timer = options.timeoutMs ? setTimeout(() => {
-      child.kill("SIGKILL");
-      reject(new Error("tool_timeout"));
-    }, options.timeoutMs) : null;
-    child.stdout?.on("data", (chunk) => {
-      stdout += chunk.toString();
-    });
-    child.stderr?.on("data", (chunk) => {
-      stderr += chunk.toString();
-    });
-    child.on("error", (error) => {
-      if (timer) clearTimeout(timer);
-      reject(error);
-    });
-    child.on("close", (code) => {
-      if (timer) clearTimeout(timer);
-      finish({
-        exitCode: code ?? 1,
-        stdout: stdout.trim(),
-        stderr: stderr.trim(),
-        command: [command, ...args].join(" ")
-      });
-    });
-  });
-}
-async function installPlateDeps(flintPath, plateName) {
-  const plate = await getPlate(flintPath, plateName);
-  if (!plate) {
-    throw new Error(`Plate not found: ${plateName}`);
-  }
-  return spawnBufferedProcess("pnpm", ["install"], { cwd: plate.path });
-}
-async function buildPlate(flintPath, plateName) {
-  const plate = await getPlate(flintPath, plateName);
-  if (!plate) {
-    throw new Error(`Plate not found: ${plateName}`);
-  }
-  const result = await spawnBufferedProcess("pnpm", ["build"], { cwd: plate.path });
-  if (result.exitCode !== 0) {
-    return result;
-  }
-  const entryPath = resolvePlateEntryPath(plate.path, plate.manifest);
-  if (!await fileExists2(entryPath)) {
-    throw new Error(`Plate build did not produce entry file: ${relative(plate.path, entryPath)}`);
-  }
-  return result;
-}
-async function runPlateTool(flintPath, plateName, toolName, args = [], options = {}) {
-  const plate = await getPlate(flintPath, plateName);
-  if (!plate) {
-    throw new Error(`Plate not found: ${plateName}`);
-  }
-  const tool = plate.manifest.tools?.find((entry) => normalizePlateName(entry.name) === normalizePlateName(toolName));
-  if (!tool) {
-    throw new Error(`Tool not found: ${toolName}`);
-  }
-  const commandPath = resolve2(plate.path, tool.command);
-  if (!await fileExists2(commandPath)) {
-    throw new Error(`Tool command not found: ${relative(plate.path, commandPath)}`);
-  }
-  const runner = resolveToolCommand(commandPath);
-  return spawnBufferedProcess(runner.command, [...runner.args, ...args], {
-    cwd: flintPath,
-    env: {
-      FLINT_ROOT: resolve2(flintPath),
-      PLATE_ROOT: plate.path,
-      PLATE_NAME: plate.manifest.name
-    },
-    timeoutMs: options.timeoutMs
-  });
-}
-async function listPlateTools(flintPath) {
-  const plates = await listPlates(flintPath);
-  return plates.flatMap((plate) => (plate.manifest.tools ?? []).map((tool) => ({ plate, tool })));
-}
-function spawnPlateDevServer(flintPath, plate) {
-  return spawn("pnpm", ["dev"], {
-    cwd: plate.path,
-    env: {
-      ...process.env,
-      FLINT_ROOT: resolve2(flintPath),
-      PLATE_ROOT: plate.path,
-      PLATE_NAME: plate.manifest.name
-    },
-    stdio: "inherit"
-  });
-}
 function getIdentityStatePath(flintPath) {
-  return join72(getFlintConfigDir(flintPath), "identity.json");
+  return join62(getFlintConfigDir(flintPath), "identity.json");
 }
 function getPersonFilePath(flintPath, name) {
   const personName = name.startsWith("@") ? name : `@${name}`;
-  return join72(flintPath, "Mesh", "People", `${personName}.md`);
+  return join62(flintPath, "Mesh", "People", `${personName}.md`);
 }
 async function readIdentityState(flintPath) {
   try {
-    const content = await readFile32(getIdentityStatePath(flintPath), "utf-8");
+    const content = await readFile22(getIdentityStatePath(flintPath), "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -3249,8 +2719,8 @@ async function readIdentityState(flintPath) {
 }
 async function writeIdentityState(flintPath, state) {
   const statePath = getIdentityStatePath(flintPath);
-  await mkdir52(getFlintConfigDir(flintPath), { recursive: true });
-  await writeFile42(statePath, JSON.stringify(state, null, 2));
+  await mkdir42(getFlintConfigDir(flintPath), { recursive: true });
+  await writeFile32(statePath, JSON.stringify(state, null, 2));
 }
 async function personExists(flintPath, name) {
   try {
@@ -3262,9 +2732,9 @@ async function personExists(flintPath, name) {
 }
 async function createPersonFile(flintPath, name) {
   const filePath = getPersonFilePath(flintPath, name);
-  const dir = join72(flintPath, "Mesh", "People");
-  await mkdir52(dir, { recursive: true });
-  await writeFile42(filePath, "");
+  const dir = join62(flintPath, "Mesh", "People");
+  await mkdir42(dir, { recursive: true });
+  await writeFile32(filePath, "");
   return filePath;
 }
 async function setIdentity(flintPath, name) {
@@ -3289,19 +2759,19 @@ function parseArtifactFile(content) {
     return { frontmatter: {}, body: content };
   }
   const frontmatterSource = match[1] ?? "";
-  const frontmatter = parseYaml2(frontmatterSource, { logLevel: "error" }) ?? {};
+  const frontmatter = parseYaml(frontmatterSource, { logLevel: "error" }) ?? {};
   const body = content.slice(match[0].length);
   return { frontmatter, body };
 }
 function stringifyArtifact(frontmatter, body) {
   return `---
-${stringifyYaml2(frontmatter).trimEnd()}
+${stringifyYaml(frontmatter).trimEnd()}
 ---
 
 ${body.trimStart()}`;
 }
 function normalizeRelativePath(flintPath, filePath) {
-  return relative2(flintPath, filePath).replace(/\\/g, "/");
+  return relative(flintPath, filePath).replace(/\\/g, "/");
 }
 function getArtifactTitleFromFilename(filename) {
   return filename.endsWith(".md") ? filename.slice(0, -3) : filename;
@@ -3335,10 +2805,10 @@ function normalizeIncrement(value) {
 }
 var SKIP_DIRS = /* @__PURE__ */ new Set(["Agents", "Archive", "node_modules", ".git"]);
 async function collectMarkdownFiles(dir, skipDirs = SKIP_DIRS) {
-  const entries = await readdir32(dir, { withFileTypes: true }).catch(() => []);
+  const entries = await readdir22(dir, { withFileTypes: true }).catch(() => []);
   const files = [];
   for (const entry of entries) {
-    const entryPath = join82(dir, entry.name);
+    const entryPath = join72(dir, entry.name);
     if (entry.isDirectory()) {
       if (skipDirs.has(entry.name)) continue;
       files.push(...await collectMarkdownFiles(entryPath, skipDirs));
@@ -3354,7 +2824,7 @@ function syntheticId(relativePath) {
   return createHash("sha256").update(relativePath).digest("hex").slice(0, 32);
 }
 async function readArtifactAtPath(flintPath, filePath) {
-  const content = await readFile42(filePath, "utf8").catch(() => null);
+  const content = await readFile32(filePath, "utf8").catch(() => null);
   if (content === null) return null;
   const parsed = parseArtifactFile(content);
   const relPath = normalizeRelativePath(flintPath, filePath);
@@ -3362,15 +2832,15 @@ async function readArtifactAtPath(flintPath, filePath) {
   return {
     id,
     path: relPath,
-    filename: basename2(filePath),
+    filename: basename(filePath),
     frontmatter: parsed.frontmatter,
     body: parsed.body
   };
 }
 async function collectAllArtifactFiles(flintPath) {
   const [meshFiles, shardFiles] = await Promise.all([
-    collectMarkdownFiles(join82(flintPath, "Mesh")),
-    collectMarkdownFiles(join82(flintPath, "Shards"))
+    collectMarkdownFiles(join72(flintPath, "Mesh")),
+    collectMarkdownFiles(join72(flintPath, "Shards"))
   ]);
   return [...meshFiles, ...shardFiles];
 }
@@ -3452,7 +2922,7 @@ function sanitizeOffset(offset) {
   return Math.max(0, Math.trunc(offset));
 }
 async function queryArtifacts(flintPath, query = {}) {
-  const files = query.includeShards ? await collectAllArtifactFiles(flintPath) : await collectMarkdownFiles(join82(flintPath, "Mesh"));
+  const files = query.includeShards ? await collectAllArtifactFiles(flintPath) : await collectMarkdownFiles(join72(flintPath, "Mesh"));
   const records = await Promise.all(files.map((filePath) => readArtifactAtPath(flintPath, filePath)));
   const matching = records.filter((record) => record !== null).filter((record) => matchesArtifactQuery(record, query)).sort((left, right) => compareArtifactSearchMatch(left, right, query));
   const limit = sanitizeLimit(query.limit);
@@ -3487,19 +2957,19 @@ async function updateArtifactById(flintPath, id, patch) {
     ...patch.frontmatter ?? {}
   };
   const nextBody = patch.body ?? found.artifact.body;
-  await writeFile52(found.absolutePath, stringifyArtifact(nextFrontmatter, nextBody), "utf8");
+  await writeFile42(found.absolutePath, stringifyArtifact(nextFrontmatter, nextBody), "utf8");
   return (await getArtifactById(flintPath, id))?.artifact ?? null;
 }
 function getArchiveDestination(flintPath, absolutePath) {
-  const meshRoot = join82(flintPath, "Mesh");
-  const relativeToMesh = relative2(meshRoot, absolutePath).replace(/\\/g, "/");
+  const meshRoot = join72(flintPath, "Mesh");
+  const relativeToMesh = relative(meshRoot, absolutePath).replace(/\\/g, "/");
   if (relativeToMesh.startsWith("Archive/")) {
     throw new Error("Artifact is already archived");
   }
   if (relativeToMesh.startsWith("Types/")) {
-    return join82(meshRoot, "Archive", relativeToMesh.slice("Types/".length));
+    return join72(meshRoot, "Archive", relativeToMesh.slice("Types/".length));
   }
-  return join82(meshRoot, "Archive", relativeToMesh);
+  return join72(meshRoot, "Archive", relativeToMesh);
 }
 async function deleteArtifactById(flintPath, id, options = {}) {
   const found = await getArtifactById(flintPath, id);
@@ -3507,18 +2977,18 @@ async function deleteArtifactById(flintPath, id, options = {}) {
     return null;
   }
   if (!options.archive) {
-    await rm22(found.absolutePath);
+    await rm6(found.absolutePath);
     return {
       artifact: found.artifact,
       archived: false
     };
   }
   const destinationPath = getArchiveDestination(flintPath, found.absolutePath);
-  const existing = await readFile42(destinationPath, "utf8").then(() => true).catch(() => false);
+  const existing = await readFile32(destinationPath, "utf8").then(() => true).catch(() => false);
   if (existing) {
     throw new Error(`Archive destination already exists: ${normalizeRelativePath(flintPath, destinationPath)}`);
   }
-  await mkdir6(dirname22(destinationPath), { recursive: true });
+  await mkdir52(dirname22(destinationPath), { recursive: true });
   await rename5(found.absolutePath, destinationPath);
   const archivedArtifact = await readArtifactAtPath(flintPath, destinationPath);
   if (!archivedArtifact) {
@@ -3577,7 +3047,7 @@ async function renameArtifact(flintPath, id, newTitle) {
     return null;
   }
   const nextTitle = normalizeNewArtifactTitle(newTitle);
-  const oldFilename = basename2(found.absolutePath);
+  const oldFilename = basename(found.absolutePath);
   const oldTitle = getArtifactTitleFromFilename(oldFilename);
   const nextFilename = buildRenamedFilename(oldFilename, nextTitle);
   const nextLinkTitle = getArtifactTitleFromFilename(nextFilename);
@@ -3589,19 +3059,19 @@ async function renameArtifact(flintPath, id, newTitle) {
       modifiedFiles: []
     };
   }
-  const destinationPath = join82(dirname22(found.absolutePath), nextFilename);
-  const existing = await readFile42(destinationPath, "utf8").then(() => true).catch(() => false);
+  const destinationPath = join72(dirname22(found.absolutePath), nextFilename);
+  const existing = await readFile32(destinationPath, "utf8").then(() => true).catch(() => false);
   if (existing) {
     throw new Error(`Artifact already exists at ${normalizeRelativePath(flintPath, destinationPath)}`);
   }
   await rename5(found.absolutePath, destinationPath);
-  const meshFiles = await collectMarkdownFiles(join82(flintPath, "Mesh"));
+  const meshFiles = await collectMarkdownFiles(join72(flintPath, "Mesh"));
   const modifiedFiles = /* @__PURE__ */ new Set([normalizeRelativePath(flintPath, destinationPath)]);
   for (const filePath of meshFiles) {
-    const content = await readFile42(filePath, "utf8");
+    const content = await readFile32(filePath, "utf8");
     const nextContent = rewriteWikilinks(content, oldTitle, nextLinkTitle);
     if (nextContent !== content) {
-      await writeFile52(filePath, nextContent, "utf8");
+      await writeFile42(filePath, nextContent, "utf8");
       modifiedFiles.add(normalizeRelativePath(flintPath, filePath));
     }
   }
@@ -3622,8 +3092,8 @@ function extractNumberFromFilename(filename, typeName) {
   return number ? Number.parseInt(number, 10) : null;
 }
 async function getNextTypedArtifactNumber(flintPath, typeName) {
-  const files = await collectMarkdownFiles(join82(flintPath, "Mesh"));
-  const numbers = files.map((filePath) => extractNumberFromFilename(basename2(filePath), typeName)).filter((value) => value !== null);
+  const files = await collectMarkdownFiles(join72(flintPath, "Mesh"));
+  const numbers = files.map((filePath) => extractNumberFromFilename(basename(filePath), typeName)).filter((value) => value !== null);
   return numbers.length > 0 ? Math.max(...numbers) + 1 : 1;
 }
 function asStringArray(value) {
@@ -3708,9 +3178,9 @@ async function createTaskArtifact(flintPath, data) {
     ...notes.length > 0 ? notes.map((note) => `- ${note}`) : ["-"],
     ""
   ];
-  const filePath = join82(flintPath, "Mesh", "Types", "Tasks", `(Task) ${number} ${title}.md`);
-  await mkdir6(dirname22(filePath), { recursive: true });
-  await writeFile52(filePath, stringifyArtifact(frontmatter, bodyLines.join("\n")), "utf8");
+  const filePath = join72(flintPath, "Mesh", "Types", "Tasks", `(Task) ${number} ${title}.md`);
+  await mkdir52(dirname22(filePath), { recursive: true });
+  await writeFile42(filePath, stringifyArtifact(frontmatter, bodyLines.join("\n")), "utf8");
   const created = await readArtifactAtPath(flintPath, filePath);
   if (!created) {
     throw new Error("Failed to create task artifact");
@@ -3731,9 +3201,9 @@ async function createNoteArtifact(flintPath, tag, data) {
     frontmatter.authors = [`[[${identity.person}]]`];
   }
   const body = typeof data.body === "string" && data.body.trim() ? data.body.trim() : "";
-  const filePath = join82(flintPath, "Mesh", "Notes", `${title}.md`);
-  await mkdir6(dirname22(filePath), { recursive: true });
-  await writeFile52(filePath, stringifyArtifact(frontmatter, body), "utf8");
+  const filePath = join72(flintPath, "Mesh", "Notes", `${title}.md`);
+  await mkdir52(dirname22(filePath), { recursive: true });
+  await writeFile42(filePath, stringifyArtifact(frontmatter, body), "utf8");
   const created = await readArtifactAtPath(flintPath, filePath);
   if (!created) {
     throw new Error("Failed to create note artifact");
@@ -3804,9 +3274,9 @@ async function createProposalArtifact(flintPath, data) {
     ...notes.length > 0 ? notes.map((note) => `- ${note}`) : ["-"],
     ""
   ];
-  const filePath = join82(flintPath, "Mesh", "Types", "Proposals", `(Proposal) ${number} ${title}.md`);
-  await mkdir6(dirname22(filePath), { recursive: true });
-  await writeFile52(filePath, stringifyArtifact(frontmatter, bodyLines.join("\n")), "utf8");
+  const filePath = join72(flintPath, "Mesh", "Types", "Proposals", `(Proposal) ${number} ${title}.md`);
+  await mkdir52(dirname22(filePath), { recursive: true });
+  await writeFile42(filePath, stringifyArtifact(frontmatter, bodyLines.join("\n")), "utf8");
   const created = await readArtifactAtPath(flintPath, filePath);
   if (!created) {
     throw new Error("Failed to create proposal artifact");
@@ -3814,9 +3284,9 @@ async function createProposalArtifact(flintPath, data) {
   return created;
 }
 async function writeStubExclusive(basePath, content) {
-  await mkdir6(dirname22(basePath), { recursive: true });
+  await mkdir52(dirname22(basePath), { recursive: true });
   try {
-    await writeFile52(basePath, content, { flag: "wx" });
+    await writeFile42(basePath, content, { flag: "wx" });
     return basePath;
   } catch (err) {
     if (err.code !== "EEXIST") throw err;
@@ -3826,7 +3296,7 @@ async function writeStubExclusive(basePath, content) {
   for (let n = 2; n < 1e4; n++) {
     const candidate = `${stem} ${n}${ext}`;
     try {
-      await writeFile52(candidate, content, { flag: "wx" });
+      await writeFile42(candidate, content, { flag: "wx" });
       return candidate;
     } catch (err) {
       if (err.code !== "EEXIST") throw err;
@@ -3834,6 +3304,33 @@ async function writeStubExclusive(basePath, content) {
   }
   throw new Error(`Could not find available stub number for ${basePath}`);
 }
+async function createNotepadArtifact(flintPath, data) {
+  const title = typeof data.title === "string" && data.title.trim() ? data.title.trim() : "New Notepad";
+  const number = String(await getNextTypedArtifactNumber(flintPath, "Notepad")).padStart(3, "0");
+  const identity = await getIdentity(flintPath);
+  const frontmatter = {
+    id: randomUUID3(),
+    tags: ["#ntpd/notepad"],
+    status: "active",
+    template: "[[tmp-ntpd-notepad-v1.0]]"
+  };
+  if (identity) frontmatter.authors = [`[[${identity.person}]]`];
+  const initialMessage = typeof data.initialMessage === "string" && data.initialMessage.trim() ? data.initialMessage.trim() : "";
+  const bodyLines = [
+    "# 1",
+    "",
+    initialMessage,
+    ""
+  ];
+  const filePath = join72(flintPath, "Mesh", "Types", "Notepads", `(Notepad) ${number} ${title}.md`);
+  await mkdir52(dirname22(filePath), { recursive: true });
+  await writeFile42(filePath, stringifyArtifact(frontmatter, bodyLines.join("\n")), "utf8");
+  const created = await readArtifactAtPath(flintPath, filePath);
+  if (!created) {
+    throw new Error("Failed to create notepad artifact");
+  }
+  return created;
+}
 async function createStubArtifact(flintPath, data) {
   const relativePath = typeof data.path === "string" ? data.path : "";
   if (!relativePath) {
@@ -3855,7 +3352,7 @@ async function createStubArtifact(flintPath, data) {
 
 This artifact is being created by an agent session. Content will replace this stub shortly.
 `;
-  const basePath = join82(flintPath, relativePath);
+  const basePath = join72(flintPath, relativePath);
   const filePath = await writeStubExclusive(basePath, stringifyArtifact(frontmatter, body));
   const created = await readArtifactAtPath(flintPath, filePath);
   if (!created) {
@@ -3871,6 +3368,9 @@ async function createArtifactFromTemplate(flintPath, request) {
     case "tmp-prop-proposal-v0.1":
     case "tmp-prop-proposal":
       return createProposalArtifact(flintPath, request.data);
+    case "tmp-ntpd-notepad-v1.0":
+    case "tmp-ntpd-notepad":
+      return createNotepadArtifact(flintPath, request.data);
     case "tmp-f-concept-v0.1":
       return createNoteArtifact(flintPath, "#note/concept", request.data);
     case "tmp-f-record-v0.1":
@@ -3881,24 +3381,24 @@ async function createArtifactFromTemplate(flintPath, request) {
       throw new Error(`Unsupported template: ${request.template}`);
   }
 }
-var execAsync3 = promisify3(exec3);
+var execAsync2 = promisify2(exec2);
 async function pathExists2(path) {
   try {
-    await stat52(path);
+    await stat42(path);
     return true;
   } catch {
     return false;
   }
 }
 function getWorkspaceRepositoriesDir(flintPath) {
-  return join92(flintPath, "Workspace", "Repos");
+  return join82(flintPath, "Workspace", "Repos");
 }
 function getRepositoryPath(flintPath, name) {
-  return join92(getWorkspaceRepositoriesDir(flintPath), name);
+  return join82(getWorkspaceRepositoriesDir(flintPath), name);
 }
 async function createRepository(flintPath, name, remote) {
   const repositoriesDir = getWorkspaceRepositoriesDir(flintPath);
-  await mkdir7(repositoriesDir, { recursive: true });
+  await mkdir6(repositoriesDir, { recursive: true });
   const repoPath = getRepositoryPath(flintPath, name);
   if (await pathExists2(repoPath)) {
     throw new Error(`Repository folder already exists: ${repoPath}`);
@@ -3906,25 +3406,25 @@ async function createRepository(flintPath, name, remote) {
   if (remote) {
     return cloneRepository(flintPath, name, remote);
   }
-  await mkdir7(repoPath, { recursive: true });
+  await mkdir6(repoPath, { recursive: true });
   try {
-    await execAsync3("git init", { cwd: repoPath });
+    await execAsync2("git init", { cwd: repoPath });
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    await rm32(repoPath, { recursive: true, force: true });
+    await rm22(repoPath, { recursive: true, force: true });
     throw new Error(`Failed to initialize repository: ${message}`);
   }
   return repoPath;
 }
 async function cloneRepository(flintPath, name, url) {
   const repositoriesDir = getWorkspaceRepositoriesDir(flintPath);
-  await mkdir7(repositoriesDir, { recursive: true });
+  await mkdir6(repositoriesDir, { recursive: true });
   const repoPath = getRepositoryPath(flintPath, name);
   if (await pathExists2(repoPath)) {
     throw new Error(`Repository folder already exists: ${repoPath}`);
   }
   try {
-    await execAsync3(`git clone "${url}" "${repoPath}"`);
+    await execAsync2(`git clone "${url}" "${repoPath}"`);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     throw new Error(`Failed to clone repository: ${message}`);
@@ -3936,19 +3436,19 @@ async function removeRepositoryFolder(flintPath, name) {
   if (!await pathExists2(repoPath)) {
     return false;
   }
-  await rm32(repoPath, { recursive: true, force: true });
+  await rm22(repoPath, { recursive: true, force: true });
   return true;
 }
 async function updateRepository(flintPath, name, url) {
   const repoPath = getRepositoryPath(flintPath, name);
   if (await pathExists2(repoPath)) {
     try {
-      await execAsync3("git rev-parse HEAD", { cwd: repoPath });
+      await execAsync2("git rev-parse HEAD", { cwd: repoPath });
     } catch {
-      await rm32(repoPath, { recursive: true, force: true });
+      await rm22(repoPath, { recursive: true, force: true });
       return cloneRepository(flintPath, name, url);
     }
-    await execAsync3("git pull", { cwd: repoPath });
+    await execAsync2("git pull", { cwd: repoPath });
     return repoPath;
   }
   return cloneRepository(flintPath, name, url);
@@ -3969,27 +3469,27 @@ async function getRepositoryStatus(flintPath) {
   return statuses;
 }
 function getSourceRepositoriesDir(flintPath) {
-  return join92(flintPath, "Sources", "Repos");
+  return join82(flintPath, "Sources", "Repos");
 }
 function getSourceRepositoryPath(flintPath, name) {
-  return join92(getSourceRepositoriesDir(flintPath), name);
+  return join82(getSourceRepositoriesDir(flintPath), name);
 }
 async function cloneSourceRepository(flintPath, name, url) {
   const repositoriesDir = getSourceRepositoriesDir(flintPath);
-  await mkdir7(repositoriesDir, { recursive: true });
+  await mkdir6(repositoriesDir, { recursive: true });
   const repoPath = getSourceRepositoryPath(flintPath, name);
   if (await pathExists2(repoPath)) {
     throw new Error(`Source repository folder already exists: ${repoPath}`);
   }
   try {
-    await execAsync3(`git clone --depth 1 "${url}" "${repoPath}"`);
+    await execAsync2(`git clone --depth 1 "${url}" "${repoPath}"`);
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     throw new Error(`Failed to clone source repository: ${message}`);
   }
-  const gitDir = join92(repoPath, ".git");
+  const gitDir = join82(repoPath, ".git");
   try {
-    await rm32(gitDir, { recursive: true, force: true });
+    await rm22(gitDir, { recursive: true, force: true });
   } catch {
   }
   return repoPath;
@@ -3999,7 +3499,7 @@ async function removeSourceRepositoryFolder(flintPath, name) {
   if (!await pathExists2(repoPath)) {
     return false;
   }
-  await rm32(repoPath, { recursive: true, force: true });
+  await rm22(repoPath, { recursive: true, force: true });
   return true;
 }
 async function updateSourceRepository(flintPath, name, url) {
@@ -4022,12 +3522,12 @@ async function getSourceRepositoryStatus(flintPath) {
   return statuses;
 }
 function getStatePath(flintPath) {
-  return join102(getFlintConfigDir(flintPath), "references.json");
+  return join92(getFlintConfigDir(flintPath), "references.json");
 }
 async function readReferencesState(flintPath) {
   const statePath = getStatePath(flintPath);
   try {
-    const content = await readFile52(statePath, "utf-8");
+    const content = await readFile42(statePath, "utf-8");
     const parsed = JSON.parse(content);
     if (parsed.version === 2) {
       return parsed;
@@ -4040,8 +3540,8 @@ async function readReferencesState(flintPath) {
 async function writeReferencesState(flintPath, state) {
   const statePath = getStatePath(flintPath);
   const dir = getFlintConfigDir(flintPath);
-  await mkdir8(dir, { recursive: true });
-  await writeFile6(statePath, JSON.stringify(state, null, 2) + "\n");
+  await mkdir7(dir, { recursive: true });
+  await writeFile52(statePath, JSON.stringify(state, null, 2) + "\n");
 }
 async function getCodebaseDeclarations(flintPath) {
   const config = await readFlintToml(flintPath);
@@ -4103,7 +3603,7 @@ async function removeDeclaration(flintPath, name) {
 }
 async function pathExists22(p) {
   try {
-    await stat62(p);
+    await stat52(p);
     return true;
   } catch {
     return false;
@@ -4159,7 +3659,7 @@ async function unfulfill(flintPath, name) {
   state.flints = state.flints.filter((f) => f.name.toLowerCase() !== name.toLowerCase());
   await writeReferencesState(flintPath, state);
 }
-async function resolve3(flintPath, type, name) {
+async function resolve2(flintPath, type, name) {
   const state = await readReferencesState(flintPath);
   const normalized = name.toLowerCase();
   if (type === "codebase") {
@@ -4262,29 +3762,29 @@ async function autoFulfillFlints(flintPath) {
   return { fulfilled, failed };
 }
 function getReferencesMetadataDir(flintPath) {
-  return join102(flintPath, "Mesh", "Metadata", "References");
+  return join92(flintPath, "Mesh", "Metadata", "References");
 }
 function getCodebaseMetadataDir(flintPath) {
-  return join102(flintPath, "Mesh", "Metadata", "References", "Codebase");
+  return join92(flintPath, "Mesh", "Metadata", "References", "Codebase");
 }
 function getFlintMetadataDir(flintPath) {
-  return join102(flintPath, "Mesh", "Metadata", "References", "Flints");
+  return join92(flintPath, "Mesh", "Metadata", "References", "Flints");
 }
 function getCodebaseMetadataPath(flintPath, name) {
   const { snake } = nameFormats(name);
-  return join102(getCodebaseMetadataDir(flintPath), `rf-cb-${snake}.md`);
+  return join92(getCodebaseMetadataDir(flintPath), `rf-cb-${snake}.md`);
 }
 function getFlintMetadataPath(flintPath, name) {
   const { snake } = nameFormats(name);
-  return join102(getFlintMetadataDir(flintPath), `rf-fl-${snake}.md`);
+  return join92(getFlintMetadataDir(flintPath), `rf-fl-${snake}.md`);
 }
 async function ensureReferenceMetadataDirs(flintPath) {
-  await mkdir8(getCodebaseMetadataDir(flintPath), { recursive: true });
-  await mkdir8(getFlintMetadataDir(flintPath), { recursive: true });
+  await mkdir7(getCodebaseMetadataDir(flintPath), { recursive: true });
+  await mkdir7(getFlintMetadataDir(flintPath), { recursive: true });
 }
 async function extractMetadataPreserved(filePath) {
   try {
-    const content = await readFile52(filePath, "utf-8");
+    const content = await readFile42(filePath, "utf-8");
     const idMatch = content.match(/^id:\s*(.+)$/m);
     const id = idMatch ? idMatch[1].trim() : randomUUID22();
     const notesMatch = content.match(/## Notes\n([\s\S]*)$/);
@@ -4311,11 +3811,11 @@ Execute \`flint resolve codebase "${name}"\` to get the local path.
 ${notes}
 `;
   try {
-    const existing = await readFile52(filePath, "utf-8");
+    const existing = await readFile42(filePath, "utf-8");
     if (existing === content) return false;
   } catch {
   }
-  await writeFile6(filePath, content);
+  await writeFile52(filePath, content);
   return true;
 }
 async function generateFlintMetadata(flintPath, name) {
@@ -4335,11 +3835,11 @@ Execute \`flint resolve flint "${name}"\` to get the local path.
 ${notes}
 `;
   try {
-    const existing = await readFile52(filePath, "utf-8");
+    const existing = await readFile42(filePath, "utf-8");
     if (existing === content) return false;
   } catch {
   }
-  await writeFile6(filePath, content);
+  await writeFile52(filePath, content);
   return true;
 }
 async function syncReferenceMetadata(flintPath) {
@@ -4367,14 +3867,14 @@ async function syncReferenceMetadata(flintPath) {
     }
   }
   const removed = [];
-  const { readdir: readdir10 } = await import("fs/promises");
+  const { readdir: readdir9 } = await import("fs/promises");
   try {
     const cbDir = getCodebaseMetadataDir(flintPath);
-    const files = await readdir10(cbDir);
+    const files = await readdir9(cbDir);
     const declaredSnakes = new Set(codebaseDecls.map((d) => `rf-cb-${nameFormats(d.name).snake}.md`));
     for (const file of files) {
       if (file.startsWith("rf-cb-") && !declaredSnakes.has(file)) {
-        await rm42(join102(cbDir, file)).catch(() => {
+        await rm32(join92(cbDir, file)).catch(() => {
         });
         removed.push(file.replace(".md", ""));
       }
@@ -4383,11 +3883,11 @@ async function syncReferenceMetadata(flintPath) {
   }
   try {
     const flDir = getFlintMetadataDir(flintPath);
-    const files = await readdir10(flDir);
+    const files = await readdir9(flDir);
     const declaredSnakes = new Set(flintDecls.map((d) => `rf-fl-${nameFormats(d.name).snake}.md`));
     for (const file of files) {
       if (file.startsWith("rf-fl-") && !declaredSnakes.has(file)) {
-        await rm42(join102(flDir, file)).catch(() => {
+        await rm32(join92(flDir, file)).catch(() => {
         });
         removed.push(file.replace(".md", ""));
       }
@@ -4396,7 +3896,7 @@ async function syncReferenceMetadata(flintPath) {
   }
   return { created, removed, unchanged };
 }
-var execFileAsync = promisify4(execFile);
+var execFileAsync = promisify3(execFile);
 var TINDERBOX_CONFIG_FILENAME = "tinderbox.toml";
 function isRecord(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
@@ -4414,7 +3914,7 @@ function isDirectionalConnection(value) {
   return "from" in value && "to" in value;
 }
 function getConfigPath(root) {
-  return join112(root, TINDERBOX_CONFIG_FILENAME);
+  return join102(root, TINDERBOX_CONFIG_FILENAME);
 }
 function getTinderboxFlintMode(declaration) {
   if (declaration.mode) {
@@ -4427,7 +3927,7 @@ function getTinderboxFolderName(name) {
 }
 async function pathExists3(path) {
   try {
-    await stat72(path);
+    await stat62(path);
     return true;
   } catch {
     return false;
@@ -4474,7 +3974,7 @@ function formatTinderboxToml(config) {
 `;
 }
 async function writeTinderboxToml(root, config) {
-  await writeFile7(getConfigPath(root), formatTinderboxToml(config));
+  await writeFile6(getConfigPath(root), formatTinderboxToml(config));
 }
 function parseTinderboxToml(content) {
   const parsed = parse(content);
@@ -4543,7 +4043,7 @@ function parseTinderboxToml(content) {
   };
 }
 async function readTinderboxToml(root) {
-  const content = await readFile6(getConfigPath(root), "utf-8");
+  const content = await readFile52(getConfigPath(root), "utf-8");
   const config = parseTinderboxToml(content);
   await validateTinderboxToml(root, config);
   return config;
@@ -4552,7 +4052,7 @@ async function validateTinderboxToml(root, config) {
   if (!config.tinderbox.name.trim()) {
     throw new Error("Invalid tinderbox.toml: [tinderbox].name must be a non-empty string");
   }
-  if (await pathExists3(join112(root, "flint.toml"))) {
+  if (await pathExists3(join102(root, "flint.toml"))) {
     throw new Error("Invalid tinderbox root: the tinderbox root must not also be a Flint");
   }
   if (!config.flints.required.length) {
@@ -4624,17 +4124,17 @@ function resolveTinderboxConnections(config) {
   return edges;
 }
 async function findTinderboxRoot(startPath) {
-  let current = resolve4(startPath);
-  const home = resolve4(homedir2());
+  let current = resolve3(startPath);
+  const home = resolve3(homedir2());
   try {
-    const currentStat = await stat72(current);
+    const currentStat = await stat62(current);
     if (!currentStat.isDirectory()) {
       current = dirname3(current);
     }
   } catch {
     current = dirname3(current);
   }
-  let currentDevice = (await stat72(current)).dev;
+  let currentDevice = (await stat62(current)).dev;
   while (true) {
     if (await pathExists3(getConfigPath(current))) {
       return current;
@@ -4643,7 +4143,7 @@ async function findTinderboxRoot(startPath) {
     if (current === parent || current === home) {
       return null;
     }
-    const parentStat = await stat72(parent);
+    const parentStat = await stat62(parent);
     if (parentStat.dev !== currentDevice) {
       return null;
     }
@@ -4652,13 +4152,13 @@ async function findTinderboxRoot(startPath) {
   }
 }
 async function scanTinderboxFlints(root) {
-  const entries = await readdir42(root, { withFileTypes: true });
+  const entries = await readdir32(root, { withFileTypes: true });
   const flints = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
     if (entry.name.startsWith(".")) continue;
-    const flintPath = join112(root, entry.name);
-    if (!await pathExists3(join112(flintPath, "flint.toml"))) {
+    const flintPath = join102(root, entry.name);
+    if (!await pathExists3(join102(flintPath, "flint.toml"))) {
       continue;
     }
     const config = await readFlintToml(flintPath);
@@ -4688,8 +4188,8 @@ async function reconcileTinderbox(root, config) {
       matched.push({ declaration, actual });
       continue;
     }
-    const expectedPath = join112(root, getTinderboxFolderName(declaration.name));
-    if (await pathExists3(join112(expectedPath, "flint.toml"))) {
+    const expectedPath = join102(root, getTinderboxFolderName(declaration.name));
+    if (await pathExists3(join102(expectedPath, "flint.toml"))) {
       const expectedConfig = await readFlintToml(expectedPath);
       const actualName = expectedConfig?.flint?.name;
       if (actualName && actualName !== declaration.name) {
@@ -4698,10 +4198,10 @@ async function reconcileTinderbox(root, config) {
           actual: {
             name: actualName,
             path: expectedPath,
-            folderName: basename3(expectedPath)
+            folderName: basename2(expectedPath)
           }
         });
-        renamedPaths.add(resolve4(expectedPath));
+        renamedPaths.add(resolve3(expectedPath));
         continue;
       }
     }
@@ -4714,14 +4214,14 @@ async function reconcileTinderbox(root, config) {
     if (ownedNames.has(flint.name)) {
       return false;
     }
-    return !renamedPaths.has(resolve4(flint.path));
+    return !renamedPaths.has(resolve3(flint.path));
   });
   return { matched, undeclared, missing, renamed };
 }
 function buildFlintEntry(path, name, toml) {
   const entry = {
     name,
-    path: resolve4(path),
+    path: resolve3(path),
     source: "local"
   };
   if (toml?.flint.tags?.length) {
@@ -4737,7 +4237,7 @@ async function syncRegistryForFlint(flint) {
   const entry = buildFlintEntry(flint.path, flint.name, toml);
   const byPath = await findFlintByPath(flint.path);
   if (byPath) {
-    if (byPath.name === entry.name && resolve4(byPath.path) === entry.path) {
+    if (byPath.name === entry.name && resolve3(byPath.path) === entry.path) {
       return false;
     }
     await updateFlintEntry(byPath.path, entry);
@@ -4745,7 +4245,7 @@ async function syncRegistryForFlint(flint) {
   }
   const byName = await findFlintByName(flint.name);
   if (byName) {
-    if (resolve4(byName.path) === entry.path) {
+    if (resolve3(byName.path) === entry.path) {
       return false;
     }
     await updateFlintEntry(byName.path, entry);
@@ -4766,11 +4266,11 @@ var REQUIRED_FLINT_DIRS = [
 ];
 async function ensureFlintStructure(flintPath) {
   for (const dir of REQUIRED_FLINT_DIRS) {
-    await mkdir9(join112(flintPath, dir), { recursive: true });
+    await mkdir8(join102(flintPath, dir), { recursive: true });
   }
 }
 async function materializeGitFlint(root, declaration) {
-  const tempPath = join112(root, `.tinderbox-clone-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
+  const tempPath = join102(root, `.tinderbox-clone-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
   try {
     await execFileAsync("git", ["clone", declaration.source, tempPath]);
     const config = await readFlintToml(tempPath);
@@ -4781,7 +4281,7 @@ async function materializeGitFlint(root, declaration) {
     if (actualName !== declaration.name) {
       throw new Error(`Cloned Flint name "${actualName}" does not match declared name "${declaration.name}"`);
     }
-    const destination = join112(root, getTinderboxFolderName(actualName));
+    const destination = join102(root, getTinderboxFolderName(actualName));
     if (await pathExists3(destination)) {
       throw new Error(`Destination already exists: ${destination}`);
     }
@@ -4790,11 +4290,11 @@ async function materializeGitFlint(root, declaration) {
     return {
       name: actualName,
       path: destination,
-      folderName: basename3(destination)
+      folderName: basename2(destination)
     };
   } finally {
     if (await pathExists3(tempPath)) {
-      await rm52(tempPath, { recursive: true, force: true });
+      await rm42(tempPath, { recursive: true, force: true });
     }
   }
 }
@@ -4816,7 +4316,7 @@ async function resolveDeclaredFlints(root, config, reconciliation) {
           path: actual.path,
           available: true,
           presentInRoot: true,
-          registered: !!registryEntry && resolve4(registryEntry.path) === resolve4(actual.path)
+          registered: !!registryEntry && resolve3(registryEntry.path) === resolve3(actual.path)
         });
         continue;
       }
@@ -4915,7 +4415,7 @@ async function wireTinderboxConnections(config, resolvedFlints) {
       }
       const state = await readReferencesState(from.path);
       const existing = state.flints.find((entry) => entry.name.toLowerCase() === edge.to.toLowerCase());
-      const isCurrent = !!existing && resolve4(existing.path) === resolve4(to.path) && await pathExists3(existing.path);
+      const isCurrent = !!existing && resolve3(existing.path) === resolve3(to.path) && await pathExists3(existing.path);
       if (!isCurrent) {
         await fulfillFlint(from.path, edge.to, to.path);
         changed = true;
@@ -4946,7 +4446,7 @@ async function syncTinderbox(root) {
     try {
       const existingEntry = await findFlintByName(declaration.name);
       if (existingEntry && await pathExists3(existingEntry.path)) {
-        const destination = join112(root, getTinderboxFolderName(declaration.name));
+        const destination = join102(root, getTinderboxFolderName(declaration.name));
         const moveResult = await moveFlint(existingEntry.path, destination);
         moved.push({ name: declaration.name, from: moveResult.from, to: moveResult.to });
         continue;
@@ -5009,7 +4509,7 @@ async function getConnectionDrift(config, resolvedFlints) {
     const state = await readReferencesState(from.path);
     const declarationExists = declarations.some((entry) => entry.name.toLowerCase() === edge.to.toLowerCase());
     const fulfillment = state.flints.find((entry) => entry.name.toLowerCase() === edge.to.toLowerCase());
-    const fulfillmentValid = !!fulfillment && resolve4(fulfillment.path) === resolve4(to.path) && await pathExists3(fulfillment.path);
+    const fulfillmentValid = !!fulfillment && resolve3(fulfillment.path) === resolve3(to.path) && await pathExists3(fulfillment.path);
     if (!declarationExists || !fulfillmentValid) {
       drift.push({
         from: edge.from,
@@ -5029,7 +4529,7 @@ async function checkTinderbox(root) {
   const staleRegistry = [];
   for (const flint of discovered) {
     const entry = await findFlintByName(flint.name);
-    if (!entry || resolve4(entry.path) !== resolve4(flint.path)) {
+    if (!entry || resolve3(entry.path) !== resolve3(flint.path)) {
       staleRegistry.push({
         name: flint.name,
         actualPath: flint.path,
@@ -5096,7 +4596,7 @@ async function getTinderboxStatus(root) {
       for (const edge of expectedEdges) {
         const target = resolvedByName.get(edge.to);
         const fulfillment = state.flints.find((entry) => entry.name.toLowerCase() === edge.to.toLowerCase());
-        if (target?.available && target.path && fulfillment && resolve4(fulfillment.path) === resolve4(target.path) && await pathExists3(fulfillment.path)) {
+        if (target?.available && target.path && fulfillment && resolve3(fulfillment.path) === resolve3(target.path) && await pathExists3(fulfillment.path)) {
           connectionsFulfilled++;
         }
       }
@@ -5137,20 +4637,20 @@ async function setTinderboxIdentity(root, name) {
   return { applied, failed };
 }
 async function countFiles(path) {
-  const stats = await stat72(path);
+  const stats = await stat62(path);
   if (!stats.isDirectory()) {
     return 1;
   }
-  const entries = await readdir42(path, { withFileTypes: true });
+  const entries = await readdir32(path, { withFileTypes: true });
   let count = 1;
   for (const entry of entries) {
-    count += await countFiles(join112(path, entry.name));
+    count += await countFiles(join102(path, entry.name));
   }
   return count;
 }
 async function resolveMoveSource(nameOrPath) {
-  const directPath = resolve4(nameOrPath);
-  if (await pathExists3(join112(directPath, "flint.toml"))) {
+  const directPath = resolve3(nameOrPath);
+  if (await pathExists3(join102(directPath, "flint.toml"))) {
     const config = await readFlintToml(directPath);
     const name = config?.flint?.name;
     if (!name) {
@@ -5162,23 +4662,23 @@ async function resolveMoveSource(nameOrPath) {
   if (!entry) {
     throw new Error(`Flint not found: ${nameOrPath}`);
   }
-  return { path: resolve4(entry.path), name: entry.name };
+  return { path: resolve3(entry.path), name: entry.name };
 }
 async function moveFlint(nameOrPath, destination, options = {}) {
   const source = await resolveMoveSource(nameOrPath);
-  const targetPath = resolve4(destination);
+  const targetPath = resolve3(destination);
   const targetParent = dirname3(targetPath);
   if (!await pathExists3(targetParent)) {
     throw new Error(`Destination parent does not exist: ${targetParent}`);
   }
-  if (resolve4(source.path) === targetPath) {
+  if (resolve3(source.path) === targetPath) {
     throw new Error(`Destination is the same as source: ${targetPath}`);
   }
   if (await pathExists3(targetPath)) {
     if (!options.force) {
       throw new Error(`Destination already exists: ${targetPath}`);
     }
-    await rm52(targetPath, { recursive: true, force: true });
+    await rm42(targetPath, { recursive: true, force: true });
   }
   let crossDevice = false;
   try {
@@ -5195,10 +4695,10 @@ async function moveFlint(nameOrPath, destination, options = {}) {
       countFiles(targetPath)
     ]);
     if (sourceCount !== destinationCount) {
-      await rm52(targetPath, { recursive: true, force: true });
+      await rm42(targetPath, { recursive: true, force: true });
       throw new Error("Cross-device move verification failed");
     }
-    await rm52(source.path, { recursive: true, force: true });
+    await rm42(source.path, { recursive: true, force: true });
   }
   const config = await readFlintToml(targetPath);
   const entry = buildFlintEntry(targetPath, config?.flint?.name ?? source.name, config);
@@ -5221,12 +4721,12 @@ async function moveFlint(nameOrPath, destination, options = {}) {
 async function removeTinderboxFlint(flint) {
   const entry = await findFlintByPath(flint.path);
   if (entry) {
-    const { unregisterFlint: unregisterFlint2 } = await import("./registry-YN5W7EY7-J52KXGG5.js");
+    const { unregisterFlint: unregisterFlint2 } = await import("./registry-5CNUVQN3-PCQZRXLB.js");
     await unregisterFlint2(entry.path);
   }
-  await rm52(flint.path, { recursive: true, force: true });
+  await rm42(flint.path, { recursive: true, force: true });
 }
-var execAsync4 = promisify5(exec4);
+var execAsync3 = promisify4(exec3);
 function normalizeManifest(raw, context) {
   const { repos, ...rest } = raw;
   if (repos !== void 0) {
@@ -5292,7 +4792,7 @@ async function resolveShardSource(source, flintPath, version) {
       return cloneAndResolve(url, source, version);
     }
     case "path": {
-      const resolvedPath = isAbsolute2(source.path) ? source.path : resolve5(flintPath, source.path);
+      const resolvedPath = isAbsolute2(source.path) ? source.path : resolve4(flintPath, source.path);
       if (!await exists(resolvedPath)) {
         throw new Error(`Shard path does not exist: ${resolvedPath}`);
       }
@@ -5310,15 +4810,15 @@ async function resolveShardSource(source, flintPath, version) {
   }
 }
 async function cloneAndResolve(url, source, version) {
-  const tempDir = await mkdtemp(join12(tmpdir(), "flint-shard-"));
+  const tempDir = await mkdtemp(join112(tmpdir(), "flint-shard-"));
   try {
     const branchArgs = version ? `--branch v${version}` : "";
-    await execAsync4(`git clone --depth 1 ${branchArgs} ${url} "${tempDir}"`, {
+    await execAsync3(`git clone --depth 1 ${branchArgs} ${url} "${tempDir}"`, {
       timeout: 6e4
       // 60 second timeout
     });
   } catch (err) {
-    await rm62(tempDir, { recursive: true, force: true });
+    await rm52(tempDir, { recursive: true, force: true });
     const message = err instanceof Error ? err.message : String(err);
     if (version && message.includes("not found")) {
       throw new Error(`Version v${version} not found for shard. Check available versions with: flint shard versions <name>`);
@@ -5327,7 +4827,7 @@ async function cloneAndResolve(url, source, version) {
   }
   const manifest = await readManifest(tempDir);
   if (!manifest) {
-    await rm62(tempDir, { recursive: true, force: true });
+    await rm52(tempDir, { recursive: true, force: true });
     throw new Error(`No shard.yaml found in cloned repository: ${url}`);
   }
   return {
@@ -5338,11 +4838,11 @@ async function cloneAndResolve(url, source, version) {
   };
 }
 async function readManifest(dir) {
-  const yamlPath = join12(dir, "shard.yaml");
+  const yamlPath = join112(dir, "shard.yaml");
   try {
-    const content = await readFile7(yamlPath, "utf-8");
+    const content = await readFile6(yamlPath, "utf-8");
     return normalizeManifest(
-      parseYaml3(content),
+      parseYaml2(content),
       yamlPath
     );
   } catch {
@@ -5351,13 +4851,13 @@ async function readManifest(dir) {
 }
 async function cleanupResolvedSource(resolved) {
   if (resolved.isTemp) {
-    await rm62(resolved.path, { recursive: true, force: true });
+    await rm52(resolved.path, { recursive: true, force: true });
   }
 }
 async function listRemoteVersionTags(source) {
   const url = `https://github.com/${source.owner}/${source.repo}.git`;
   try {
-    const { stdout } = await execAsync4(`git ls-remote --tags ${url}`, { timeout: 3e4 });
+    const { stdout } = await execAsync3(`git ls-remote --tags ${url}`, { timeout: 3e4 });
     const tags = [];
     for (const line of stdout.trim().split("\n")) {
       if (!line) continue;
@@ -5400,7 +4900,7 @@ async function fetchRemoteShardVersion(source) {
         return null;
       }
       const content = await response.text();
-      const manifest = parseYaml3(content);
+      const manifest = parseYaml2(content);
       return manifest?.version ?? null;
     } catch {
       if (attempt === 0) {
@@ -5424,11 +4924,11 @@ function normalizeManifest2(raw, context) {
   };
 }
 function getShardVersionStatePath(flintPath, shardName) {
-  return join13(getFlintConfigDir(flintPath), "shards", `${shardName}.json`);
+  return join12(getFlintConfigDir(flintPath), "shards", `${shardName}.json`);
 }
 async function readShardVersionState(flintPath, shardName) {
   try {
-    const content = await readFile8(getShardVersionStatePath(flintPath, shardName), "utf-8");
+    const content = await readFile7(getShardVersionStatePath(flintPath, shardName), "utf-8");
     return JSON.parse(content);
   } catch {
     return null;
@@ -5440,14 +4940,14 @@ async function getRecordedShardVersion(flintPath, shardName) {
 }
 async function recordShardVersion(flintPath, shardName, version) {
   const statePath = getShardVersionStatePath(flintPath, shardName);
-  await mkdir10(dirname4(statePath), { recursive: true });
+  await mkdir9(dirname4(statePath), { recursive: true });
   const state = {
     version: 1,
     shard: shardName,
     currentVersion: version,
     updatedAt: (/* @__PURE__ */ new Date()).toISOString()
   };
-  await writeFile8(statePath, JSON.stringify(state, null, 2) + "\n");
+  await writeFile7(statePath, JSON.stringify(state, null, 2) + "\n");
 }
 async function getDependencyWarnings(flintPath, manifest) {
   if (!manifest.dependencies?.length) return [];
@@ -5469,12 +4969,12 @@ async function getDependencyWarnings(flintPath, manifest) {
   return warnings;
 }
 async function copyDir2(src, dest, skip = []) {
-  await mkdir10(dest, { recursive: true });
-  const entries = await readdir52(src, { withFileTypes: true });
+  await mkdir9(dest, { recursive: true });
+  const entries = await readdir42(src, { withFileTypes: true });
   for (const entry of entries) {
     if (skip.includes(entry.name)) continue;
-    const srcPath = join13(src, entry.name);
-    const destPath = join13(dest, entry.name);
+    const srcPath = join12(src, entry.name);
+    const destPath = join12(dest, entry.name);
     if (entry.isDirectory()) {
       await copyDir2(srcPath, destPath, skip);
     } else {
@@ -5483,12 +4983,12 @@ async function copyDir2(src, dest, skip = []) {
   }
 }
 async function createShardStateFile(flintPath, name, shorthand) {
-  const stateDir = join13(flintPath, "Mesh", "Shards");
-  const statePath = join13(stateDir, `(Shard) ${name}.md`);
+  const stateDir = join12(flintPath, "Mesh", "Shards");
+  const statePath = join12(stateDir, `(Shard) ${name}.md`);
   if (await exists(statePath)) {
     return false;
   }
-  await mkdir10(stateDir, { recursive: true });
+  await mkdir9(stateDir, { recursive: true });
   const content = `---
 id: ${randomUUID32()}
 tags:
@@ -5500,7 +5000,7 @@ shard: ${shorthand}
 
 State for the ${name} shard.
 `;
-  await writeFile8(statePath, content);
+  await writeFile7(statePath, content);
   return true;
 }
 function processTemplate(content) {
@@ -5515,10 +5015,10 @@ function extractIdFromFrontmatter(content) {
   return idMatch?.[1]?.trim() ?? null;
 }
 async function detectMigrations(shardPath, shorthand, fromVersion, toVersion) {
-  const migrationsDir = join13(shardPath, "migrations");
+  const migrationsDir = join12(shardPath, "migrations");
   if (!await exists(migrationsDir)) return [];
   try {
-    const entries = await readdir52(migrationsDir, { withFileTypes: true });
+    const entries = await readdir42(migrationsDir, { withFileTypes: true });
     const prefix = `mig-${shorthand}-`;
     const allMigrations = [];
     for (const entry of entries) {
@@ -5550,11 +5050,11 @@ async function detectMigrations(shardPath, shorthand, fromVersion, toVersion) {
   }
 }
 async function readShardManifest(shardPath) {
-  const yamlPath = join13(shardPath, "shard.yaml");
+  const yamlPath = join12(shardPath, "shard.yaml");
   try {
-    const content = await readFile8(yamlPath, "utf-8");
+    const content = await readFile7(yamlPath, "utf-8");
     return normalizeManifest2(
-      parseYaml4(content),
+      parseYaml3(content),
       yamlPath
     );
   } catch {
@@ -5562,14 +5062,14 @@ async function readShardManifest(shardPath) {
   }
 }
 async function applyShardManifestContent(flintPath, sourcePath, manifest, options = {}) {
-  const resolvedFlintPath = resolve6(flintPath);
+  const resolvedFlintPath = resolve5(flintPath);
   let foldersCreated = 0;
   let filesInstalled = 0;
   let stateCreated = false;
   if (manifest.folders?.length) {
     for (const folder of manifest.folders) {
-      const folderPath = join13(flintPath, folder);
-      const resolvedFolderPath = resolve6(folderPath);
+      const folderPath = join12(flintPath, folder);
+      const resolvedFolderPath = resolve5(folderPath);
       if (!resolvedFolderPath.startsWith(resolvedFlintPath)) {
         console.warn(`Skipping folder outside flint: ${folder}`);
         continue;
@@ -5577,15 +5077,15 @@ async function applyShardManifestContent(flintPath, sourcePath, manifest, option
       if (!await exists(folderPath)) {
         foldersCreated++;
       }
-      await mkdir10(folderPath, { recursive: true });
+      await mkdir9(folderPath, { recursive: true });
     }
   }
   if (manifest.install?.length) {
-    const installFolderPath = join13(sourcePath, "install");
+    const installFolderPath = join12(sourcePath, "install");
     for (const entry of manifest.install) {
-      const srcFilePath = join13(installFolderPath, entry.source);
-      const destFilePath = join13(flintPath, entry.dest);
-      const resolvedDestFilePath = resolve6(destFilePath);
+      const srcFilePath = join12(installFolderPath, entry.source);
+      const destFilePath = join12(flintPath, entry.dest);
+      const resolvedDestFilePath = resolve5(destFilePath);
       if (!resolvedDestFilePath.startsWith(resolvedFlintPath)) {
         console.warn(`Skipping file outside flint: ${entry.dest}`);
         continue;
@@ -5598,7 +5098,7 @@ async function applyShardManifestContent(flintPath, sourcePath, manifest, option
       }
       let content;
       try {
-        content = await readFile8(srcFilePath, "utf-8");
+        content = await readFile7(srcFilePath, "utf-8");
       } catch {
         console.warn(`Failed to read install file: ${entry.source}`);
         continue;
@@ -5606,7 +5106,7 @@ async function applyShardManifestContent(flintPath, sourcePath, manifest, option
       let existingId = null;
       if (await exists(destFilePath)) {
         try {
-          const existingContent = await readFile8(destFilePath, "utf-8");
+          const existingContent = await readFile7(destFilePath, "utf-8");
           existingId = extractIdFromFrontmatter(existingContent);
         } catch {
         }
@@ -5615,8 +5115,8 @@ async function applyShardManifestContent(flintPath, sourcePath, manifest, option
       if (existingId) {
         content = content.replace(/^(id:\s*)[a-f0-9-]{36}/m, `$1${existingId}`);
       }
-      await mkdir10(dirname4(destFilePath), { recursive: true });
-      await writeFile8(destFilePath, content);
+      await mkdir9(dirname4(destFilePath), { recursive: true });
+      await writeFile7(destFilePath, content);
       filesInstalled++;
     }
   }
@@ -5626,16 +5126,16 @@ async function applyShardManifestContent(flintPath, sourcePath, manifest, option
   return { foldersCreated, filesInstalled, stateCreated };
 }
 async function installShardFromSource(flintPath, sourcePath, manifest, options = {}) {
-  const destPath = join13(flintPath, "Shards", manifest.name);
-  const resolvedFlintPath = resolve6(flintPath);
-  const resolvedDestPath = resolve6(destPath);
+  const destPath = join12(flintPath, "Shards", manifest.name);
+  const resolvedFlintPath = resolve5(flintPath);
+  const resolvedDestPath = resolve5(destPath);
   if (!resolvedDestPath.startsWith(resolvedFlintPath)) {
     throw new Error("Invalid shard path: outside flint directory");
   }
-  await rm7(destPath, { recursive: true, force: true });
-  await mkdir10(destPath, { recursive: true });
-  const shardYamlSrc = join13(sourcePath, "shard.yaml");
-  const shardYamlDest = join13(destPath, "shard.yaml");
+  await rm62(destPath, { recursive: true, force: true });
+  await mkdir9(destPath, { recursive: true });
+  const shardYamlSrc = join12(sourcePath, "shard.yaml");
+  const shardYamlDest = join12(destPath, "shard.yaml");
   if (await exists(shardYamlSrc)) {
     await copyFile(shardYamlSrc, shardYamlDest);
   }
@@ -5652,23 +5152,23 @@ async function installShardFromSource(flintPath, sourcePath, manifest, options =
   return { name: manifest.name, path: destPath };
 }
 async function listInstalledShards(flintPath) {
-  const shardsPath = join13(flintPath, "Shards");
+  const shardsPath = join12(flintPath, "Shards");
   try {
-    const entries = await readdir52(shardsPath, { withFileTypes: true });
+    const entries = await readdir42(shardsPath, { withFileTypes: true });
     return entries.filter((e) => e.isDirectory() && !e.name.startsWith("(System)")).map((e) => e.name);
   } catch {
     return [];
   }
 }
 async function getInstalledShardsWithVersions(flintPath) {
-  const shardsPath = join13(flintPath, "Shards");
+  const shardsPath = join12(flintPath, "Shards");
   const results = [];
   try {
-    const entries = await readdir52(shardsPath, { withFileTypes: true });
+    const entries = await readdir42(shardsPath, { withFileTypes: true });
     const folders = entries.filter((e) => e.isDirectory() && !e.name.startsWith("(System)")).map((e) => e.name);
     for (const folder of folders) {
       try {
-        const manifest = await readShardManifest(join13(shardsPath, folder));
+        const manifest = await readShardManifest(join12(shardsPath, folder));
         if (!manifest?.name || !manifest.shorthand || !manifest.version) {
           continue;
         }
@@ -5718,7 +5218,7 @@ async function updateShards(flintPath, options = {}) {
       if (pinnedVersion && pinnedVersion === info.version && !options.reinstall) {
         return {
           name: info.folderName,
-          path: join13(flintPath, "Shards", info.folderName),
+          path: join12(flintPath, "Shards", info.folderName),
           status: "skipped",
           localVersion: info.version,
           remoteVersion: pinnedVersion,
@@ -5731,7 +5231,7 @@ async function updateShards(flintPath, options = {}) {
         if (remoteVersion && compareVersions(remoteVersion, info.version) <= 0) {
           return {
             name: info.folderName,
-            path: join13(flintPath, "Shards", info.folderName),
+            path: join12(flintPath, "Shards", info.folderName),
             status: "skipped",
             localVersion: info.version,
             remoteVersion,
@@ -5742,7 +5242,7 @@ async function updateShards(flintPath, options = {}) {
       if (!source || !isGitHubSourceSpecifier(source)) {
         return {
           name: info.folderName,
-          path: join13(flintPath, "Shards", info.folderName),
+          path: join12(flintPath, "Shards", info.folderName),
           status: "skipped",
           localVersion: info.version,
           reason: "no source configured"
@@ -5755,7 +5255,7 @@ async function updateShards(flintPath, options = {}) {
       } catch {
         return {
           name: info.folderName,
-          path: join13(flintPath, "Shards", info.folderName),
+          path: join12(flintPath, "Shards", info.folderName),
           status: "failed",
           localVersion: info.version,
           reason: "failed to resolve source"
@@ -5767,7 +5267,7 @@ async function updateShards(flintPath, options = {}) {
           source,
           version: pinnedVersion
         });
-        const shardPath = join13(flintPath, "Shards", info.folderName);
+        const shardPath = join12(flintPath, "Shards", info.folderName);
         const shorthand = resolved.manifest.shorthand || info.shorthand;
         const migrations2 = await detectMigrations(
           shardPath,
@@ -5777,7 +5277,7 @@ async function updateShards(flintPath, options = {}) {
         );
         return {
           name: info.folderName,
-          path: join13(flintPath, "Shards", info.folderName),
+          path: join12(flintPath, "Shards", info.folderName),
           status: "updated",
           localVersion: info.version,
           remoteVersion: resolved.manifest.version,
@@ -5787,7 +5287,7 @@ async function updateShards(flintPath, options = {}) {
       } catch {
         return {
           name: info.folderName,
-          path: join13(flintPath, "Shards", info.folderName),
+          path: join12(flintPath, "Shards", info.folderName),
           status: "failed",
           localVersion: info.version,
           reason: "failed to install from source"
@@ -5809,7 +5309,7 @@ async function updateShards(flintPath, options = {}) {
     if (r.status === "error") {
       results.push({
         name: r.name,
-        path: join13(flintPath, "Shards", r.name),
+        path: join12(flintPath, "Shards", r.name),
         status: "failed",
         localVersion: "",
         reason: r.error?.message || "Unknown error"
@@ -5825,7 +5325,7 @@ async function updateShards(flintPath, options = {}) {
 }
 async function isDirectoryEmpty(dirPath) {
   try {
-    const entries = await readdir52(dirPath);
+    const entries = await readdir42(dirPath);
     return entries.length === 0;
   } catch {
     return true;
@@ -5839,23 +5339,23 @@ async function uninstallShard(flintPath, identifier) {
     throw new Error(`Shard "${identifier}" is not installed.`);
   }
   const shardName = matchingFolder;
-  const shardPath = join13(flintPath, "Shards", matchingFolder);
+  const shardPath = join12(flintPath, "Shards", matchingFolder);
   const folderExists = await exists(shardPath);
   if (!folderExists) {
     throw new Error(`Shard "${shardName}" is not installed.`);
   }
-  const resolvedFlintPath = resolve6(flintPath);
+  const resolvedFlintPath = resolve5(flintPath);
   const manifest = await readShardManifest(shardPath);
   if (manifest) {
     if (manifest.install?.length) {
       for (const entry of manifest.install) {
-        const filePath = join13(flintPath, entry.dest);
-        const resolvedFilePath = resolve6(filePath);
+        const filePath = join12(flintPath, entry.dest);
+        const resolvedFilePath = resolve5(filePath);
         if (!resolvedFilePath.startsWith(resolvedFlintPath)) {
           continue;
         }
         try {
-          await rm7(filePath, { force: true });
+          await rm62(filePath, { force: true });
         } catch {
         }
       }
@@ -5863,8 +5363,8 @@ async function uninstallShard(flintPath, identifier) {
     if (manifest.folders?.length) {
       const sortedFolders = [...manifest.folders].sort((a, b) => b.length - a.length);
       for (const folder of sortedFolders) {
-        const folderPath = join13(flintPath, folder);
-        const resolvedFolderPath = resolve6(folderPath);
+        const folderPath = join12(flintPath, folder);
+        const resolvedFolderPath = resolve5(folderPath);
         if (!resolvedFolderPath.startsWith(resolvedFlintPath)) {
           continue;
         }
@@ -5877,11 +5377,11 @@ async function uninstallShard(flintPath, identifier) {
       }
     }
   }
-  const resolvedShardPath = resolve6(shardPath);
+  const resolvedShardPath = resolve5(shardPath);
   if (!resolvedShardPath.startsWith(resolvedFlintPath)) {
     throw new Error(`Invalid shard path: outside flint directory`);
   }
-  await rm7(shardPath, { recursive: true, force: true });
+  await rm62(shardPath, { recursive: true, force: true });
   await removeShardFromConfig(flintPath, shardName);
   return { name: shardName, removed: true };
 }
@@ -5891,11 +5391,11 @@ async function removeOrphanedShard(flintPath, kebabName) {
     (folder) => toKebabCase(folder) === kebabName
   );
   if (matchingFolder) {
-    const shardPath = join13(flintPath, "Shards", matchingFolder);
-    const resolvedFlintPath = resolve6(flintPath);
-    const resolvedShardPath = resolve6(shardPath);
+    const shardPath = join12(flintPath, "Shards", matchingFolder);
+    const resolvedFlintPath = resolve5(flintPath);
+    const resolvedShardPath = resolve5(shardPath);
     if (resolvedShardPath.startsWith(resolvedFlintPath)) {
-      await rm7(shardPath, { recursive: true, force: true });
+      await rm62(shardPath, { recursive: true, force: true });
     }
   }
   return { name: kebabName, removed: true };
@@ -5915,7 +5415,7 @@ async function pullShard(flintPath, identifier, options) {
     shardFolders = await listInstalledShards(flintPath);
   }
   for (const folder of shardFolders) {
-    const shardPath = join13(flintPath, "Shards", folder);
+    const shardPath = join12(flintPath, "Shards", folder);
     const manifest = await readShardManifest(shardPath);
     if (!manifest) continue;
     const shardName = toKebabCase(manifest.name || folder);
@@ -5951,23 +5451,23 @@ async function scaffoldNewShard(flintPath, name, shorthand, description, options
   const shardMode = options.mode || "dev";
   const prefix = shardMode === "custom" ? "(Custom)" : "(Dev)";
   const folderName = `${prefix} ${name}`;
-  const shardPath = join13(flintPath, "Shards", folderName);
+  const shardPath = join12(flintPath, "Shards", folderName);
   if (await exists(shardPath)) {
     throw new Error(`Shard already exists: ${folderName}`);
   }
   const dirs = [
     shardPath,
-    join13(shardPath, "skills"),
-    join13(shardPath, "workflows"),
-    join13(shardPath, "templates"),
-    join13(shardPath, "knowledge"),
-    join13(shardPath, "assets"),
-    join13(shardPath, "install"),
-    join13(shardPath, "migrations"),
-    join13(shardPath, "scripts")
+    join12(shardPath, "skills"),
+    join12(shardPath, "workflows"),
+    join12(shardPath, "templates"),
+    join12(shardPath, "knowledge"),
+    join12(shardPath, "assets"),
+    join12(shardPath, "install"),
+    join12(shardPath, "migrations"),
+    join12(shardPath, "scripts")
   ];
   for (const dir of dirs) {
-    await mkdir10(dir, { recursive: true });
+    await mkdir9(dir, { recursive: true });
   }
   let shardYaml = `shard-spec: "0.1.0"
 version: "0.1.0"
@@ -5979,7 +5479,7 @@ description: ${description}
     shardYaml += `state: true
 `;
   }
-  await writeFile8(join13(shardPath, "shard.yaml"), shardYaml);
+  await writeFile7(join12(shardPath, "shard.yaml"), shardYaml);
   const setupLine = options.setup ? `  setup-${shorthand}.md    # One-time setup guide
 ` : "";
   const readmeContent = `# ${name}
@@ -6000,7 +5500,7 @@ ${setupLine}  skills/                 # sk-${shorthand}-{name}.md
   install/                # Files to install into Mesh/
 \`\`\`
 `;
-  await writeFile8(join13(shardPath, "README.md"), readmeContent);
+  await writeFile7(join12(shardPath, "README.md"), readmeContent);
   const setupRow = options.setup ? `
 | Setup | \`setup-${shorthand}.md\` | One-time setup guide |` : "";
   const stateRow = options.state ? `
@@ -6031,7 +5531,7 @@ ${description}
 
 (No knowledge files yet)
 `;
-  await writeFile8(join13(shardPath, `init-${shorthand}.md`), initContent);
+  await writeFile7(join12(shardPath, `init-${shorthand}.md`), initContent);
   if (options.setup) {
     const setupContent = `# Setup ${name}
 
@@ -6041,11 +5541,11 @@ One-time setup actions for ${name}.
 
 1. (Define setup actions here)
 `;
-    await writeFile8(join13(shardPath, `setup-${shorthand}.md`), setupContent);
+    await writeFile7(join12(shardPath, `setup-${shorthand}.md`), setupContent);
   }
   if (options.state) {
-    const stateDir = join13(flintPath, "Mesh", "Shards");
-    await mkdir10(stateDir, { recursive: true });
+    const stateDir = join12(flintPath, "Mesh", "Shards");
+    await mkdir9(stateDir, { recursive: true });
     const stateContent = `---
 id: ${randomUUID32()}
 tags:
@@ -6057,7 +5557,7 @@ shard: ${shorthand}
 
 State for the ${name} shard.
 `;
-    await writeFile8(join13(stateDir, `(Shard) ${name}.md`), stateContent);
+    await writeFile7(join12(stateDir, `(Shard) ${name}.md`), stateContent);
   }
   if (shardMode === "dev") {
     const { execSync: execSync2 } = await import("child_process");
@@ -6069,7 +5569,7 @@ State for the ${name} shard.
 }
 async function cloneShardToDev(flintPath, sourcePath, manifest) {
   const devFolderName = `(Dev) ${manifest.name}`;
-  const devPath = join13(flintPath, "Shards", devFolderName);
+  const devPath = join12(flintPath, "Shards", devFolderName);
   if (await exists(devPath)) {
     await addShardToConfig(flintPath, devFolderName, `path:./Shards/${devFolderName}`, { mode: "dev" });
     await recordShardVersion(flintPath, toKebabCase(manifest.name), manifest.version);
@@ -6081,7 +5581,7 @@ async function cloneShardToDev(flintPath, sourcePath, manifest) {
   return { name: devFolderName, path: devPath };
 }
 async function registerExistingShard(flintPath, folderName) {
-  const shardPath = join13(flintPath, "Shards", folderName);
+  const shardPath = join12(flintPath, "Shards", folderName);
   if (!await exists(shardPath)) {
     throw new Error(`Shard folder not found: Shards/${folderName}`);
   }
@@ -6103,7 +5603,7 @@ async function registerExistingShard(flintPath, folderName) {
 async function editShard(flintPath, folderName, source) {
   const { execSync: execSync2 } = await import("child_process");
   const { rename: rename42 } = await import("fs/promises");
-  const shardPath = join13(flintPath, "Shards", folderName);
+  const shardPath = join12(flintPath, "Shards", folderName);
   if (!await exists(shardPath)) {
     throw new Error(`Shard folder not found: Shards/${folderName}`);
   }
@@ -6115,21 +5615,21 @@ async function editShard(flintPath, folderName, source) {
   }
   const baseName = folderName.replace(/^\([^)]*\)\s*/, "");
   const devFolderName = `(Dev) ${baseName}`;
-  const devPath = join13(flintPath, "Shards", devFolderName);
+  const devPath = join12(flintPath, "Shards", devFolderName);
   if (await exists(devPath)) {
     throw new Error(`Dev folder already exists: Shards/${devFolderName}`);
   }
   await rename42(shardPath, devPath);
   if (isGitHubSourceSpecifier(source)) {
-    const tmpDir = join13(flintPath, ".flint", "_tmp_edit_" + Date.now());
+    const tmpDir = join12(flintPath, ".flint", "_tmp_edit_" + Date.now());
     try {
       const parsed = parseShardSource(source);
       execSync2(`git clone --depth 1 "https://github.com/${parsed.owner}/${parsed.repo}.git" "${tmpDir}"`, { stdio: "pipe", timeout: 6e4 });
-      await copyDir2(join13(tmpDir, ".git"), join13(devPath, ".git"));
+      await copyDir2(join12(tmpDir, ".git"), join12(devPath, ".git"));
     } catch {
       execSync2("git init", { cwd: devPath, stdio: "pipe" });
     } finally {
-      await rm7(tmpDir, { recursive: true, force: true });
+      await rm62(tmpDir, { recursive: true, force: true });
     }
   } else {
     execSync2("git init", { cwd: devPath, stdio: "pipe" });
@@ -6142,14 +5642,14 @@ async function editShard(flintPath, folderName, source) {
 async function freezeShard(flintPath, folderName) {
   const { execSync: execSync2 } = await import("child_process");
   const { rename: rename42 } = await import("fs/promises");
-  const shardPath = join13(flintPath, "Shards", folderName);
+  const shardPath = join12(flintPath, "Shards", folderName);
   if (!await exists(shardPath)) {
     throw new Error(`Shard folder not found: Shards/${folderName}`);
   }
   if (!folderName.startsWith("(Dev)")) {
     throw new Error(`"${folderName}" is not a dev shard.`);
   }
-  const gitDir = join13(shardPath, ".git");
+  const gitDir = join12(shardPath, ".git");
   if (!await exists(gitDir)) {
     throw new Error(`"${folderName}" has no .git directory.`);
   }
@@ -6177,11 +5677,11 @@ async function freezeShard(flintPath, folderName) {
   const decl = declarations[kebab];
   const source = decl?.source || "";
   const baseName = folderName.replace(/^\(Dev\)\s*/, "");
-  const normalPath = join13(flintPath, "Shards", baseName);
+  const normalPath = join12(flintPath, "Shards", baseName);
   if (await exists(normalPath)) {
     throw new Error(`Normal folder already exists: Shards/${baseName}`);
   }
-  await rm7(gitDir, { recursive: true, force: true });
+  await rm62(gitDir, { recursive: true, force: true });
   await rename42(shardPath, normalPath);
   await removeShardFromConfig(flintPath, kebab);
   const normalSource = isGitHubSourceSpecifier(source) ? source : `path:./Shards/${baseName}`;
@@ -6190,14 +5690,14 @@ async function freezeShard(flintPath, folderName) {
 }
 async function addShardGitRemote(flintPath, folderName, url) {
   const { execSync: execSync2 } = await import("child_process");
-  const shardPath = join13(flintPath, "Shards", folderName);
+  const shardPath = join12(flintPath, "Shards", folderName);
   if (!await exists(shardPath)) {
     throw new Error(`Shard folder not found: Shards/${folderName}`);
   }
   if (!folderName.startsWith("(Dev)")) {
     throw new Error(`"${folderName}" is not a dev shard. Only dev shards can have git remotes added.`);
   }
-  const gitDir = join13(shardPath, ".git");
+  const gitDir = join12(shardPath, ".git");
   if (!await exists(gitDir)) {
     throw new Error(`"${folderName}" has no .git directory. Run git init first.`);
   }
@@ -6236,7 +5736,7 @@ async function installDependency(flintPath, source, version) {
 }
 async function countFiles2(dirPath) {
   try {
-    const entries = await readdir62(dirPath, { withFileTypes: true });
+    const entries = await readdir52(dirPath, { withFileTypes: true });
     return entries.filter((e) => e.isFile() && e.name.endsWith(".md")).length;
   } catch {
     return 0;
@@ -6250,7 +5750,7 @@ async function checkShardHealth(flintPath) {
   for (const folder of installedFolders) {
     const kebab = toKebabCase(folder);
     if (!declaredKebabNames.has(kebab)) {
-      const shardPath = join14(flintPath, "Shards", folder);
+      const shardPath = join13(flintPath, "Shards", folder);
       const manifest = await readShardManifest(shardPath);
       if (manifest?.name && manifest?.shorthand) {
         const detectedMode = folder.startsWith("(Custom)") ? "custom" : "dev";
@@ -6276,7 +5776,7 @@ async function checkShardHealth(flintPath) {
   for (const [name, decl] of Object.entries(declarations)) {
     if (decl.source.startsWith("path:")) {
       const relativePath = decl.source.slice(5);
-      const fullPath = join14(flintPath, relativePath);
+      const fullPath = join13(flintPath, relativePath);
       if (!await exists(fullPath)) {
         results.push({
           check: `${name} (${decl.source})`,
@@ -6293,7 +5793,7 @@ async function checkShardHealth(flintPath) {
   for (const [name, decl] of Object.entries(declarations)) {
     if (decl.source.startsWith("path:") && resolveShardMode(decl) === "dev") {
       const relativePath = decl.source.slice(5);
-      const fullPath = join14(flintPath, relativePath);
+      const fullPath = join13(flintPath, relativePath);
       if (await exists(fullPath)) {
         const remoteUrl = getGitRemoteUrl(fullPath);
         if (remoteUrl) {
@@ -6316,7 +5816,7 @@ async function checkShardHealth(flintPath) {
     }
   }
   for (const folder of installedFolders) {
-    const shardPath = join14(flintPath, "Shards", folder);
+    const shardPath = join13(flintPath, "Shards", folder);
     const manifest = await readShardManifest(shardPath);
     if (!manifest) {
       results.push({
@@ -6332,7 +5832,7 @@ name: ${name}
 shorthand: ${shorthand}
 description: ${name} shard
 `;
-          await writeFile9(join14(shardPath, "shard.yaml"), yaml);
+          await writeFile8(join13(shardPath, "shard.yaml"), yaml);
         },
         actionLabel: `Create minimal shard.yaml for ${folder}`
       });
@@ -6351,21 +5851,21 @@ description: ${name} shard
   const SHARD_SPEC_DIRS_CONSUMER = ["skills", "workflows", "templates", "knowledge"];
   const SHARD_SPEC_DIRS_DEV = [...SHARD_SPEC_DIRS_CONSUMER, "assets", "install", "migrations", "scripts"];
   for (const folder of installedFolders) {
-    const shardPath = join14(flintPath, "Shards", folder);
+    const shardPath = join13(flintPath, "Shards", folder);
     const manifest = await readShardManifest(shardPath);
     const kebab = toKebabCase(folder);
     const decl = declarations[kebab];
     const mode = decl ? resolveShardMode(decl) : void 0;
     const expectedDirs = mode === "dev" ? SHARD_SPEC_DIRS_DEV : SHARD_SPEC_DIRS_CONSUMER;
     for (const dir of expectedDirs) {
-      const dirPath = join14(shardPath, dir);
+      const dirPath = join13(shardPath, dir);
       if (!await exists(dirPath)) {
         results.push({
           check: `Shards/${folder}/${dir}/`,
           status: "warning",
           message: "Missing shard-spec directory",
           action: async () => {
-            await mkdir11(dirPath, { recursive: true });
+            await mkdir10(dirPath, { recursive: true });
           },
           actionLabel: `Create ${dir}/ in ${folder}`
         });
@@ -6375,7 +5875,7 @@ description: ${name} shard
   const installedWithVersions = await getInstalledShardsWithVersions(flintPath);
   const installedVersionMap = new Map(installedWithVersions.map((s) => [s.name, s.version]));
   for (const folder of installedFolders) {
-    const shardPath = join14(flintPath, "Shards", folder);
+    const shardPath = join13(flintPath, "Shards", folder);
     const manifest = await readShardManifest(shardPath);
     if (!manifest?.dependencies?.length) continue;
     for (const dep of manifest.dependencies) {
@@ -6430,7 +5930,7 @@ description: ${name} shard
 }
 function getGitRemoteUrl(shardPath) {
   try {
-    const gitDir = join14(shardPath, ".git");
+    const gitDir = join13(shardPath, ".git");
     if (!existsSync(gitDir)) return null;
     return execSync("git remote get-url origin", {
       cwd: shardPath,
@@ -6443,7 +5943,7 @@ function getGitRemoteUrl(shardPath) {
 }
 async function healShard(flintPath, folderName) {
   const results = [];
-  const shardPath = join14(flintPath, "Shards", folderName);
+  const shardPath = join13(flintPath, "Shards", folderName);
   const kebab = toKebabCase(folderName);
   const manifest = await readShardManifest(shardPath);
   if (!manifest) {
@@ -6460,7 +5960,7 @@ name: ${name}
 shorthand: ${shorthand2}
 description: ${name} shard
 `;
-        await writeFile9(join14(shardPath, "shard.yaml"), yaml);
+        await writeFile8(join13(shardPath, "shard.yaml"), yaml);
       },
       actionLabel: `Create shard.yaml`
     });
@@ -6524,21 +6024,21 @@ description: ${name} shard
   const mode = decl ? resolveShardMode(decl) : void 0;
   const expectedDirs = mode === "dev" ? DEV_DIRS : CONSUMER_DIRS;
   for (const dir of expectedDirs) {
-    const dirPath = join14(shardPath, dir);
+    const dirPath = join13(shardPath, dir);
     if (!await exists(dirPath)) {
       results.push({
         check: `${dir}/`,
         status: "warning",
         message: "Missing directory",
         action: async () => {
-          await mkdir11(dirPath, { recursive: true });
+          await mkdir10(dirPath, { recursive: true });
         },
         actionLabel: `Create ${dir}/`
       });
     }
   }
   const shorthand = manifest?.shorthand || kebab.replace(/-/g, "").slice(0, 4);
-  const initFile = join14(shardPath, `init-${shorthand}.md`);
+  const initFile = join13(shardPath, `init-${shorthand}.md`);
   if (!await exists(initFile)) {
     results.push({
       check: `init-${shorthand}.md`,
@@ -6550,21 +6050,21 @@ description: ${name} shard
 
 Describe the shard context here.
 `;
-        await writeFile9(initFile, content);
+        await writeFile8(initFile, content);
       },
       actionLabel: `Create init-${shorthand}.md`
     });
   }
   if (manifest?.folders) {
     for (const folder of manifest.folders) {
-      const meshPath = join14(flintPath, folder);
+      const meshPath = join13(flintPath, folder);
       if (!await exists(meshPath)) {
         results.push({
           check: `${folder}`,
           status: "warning",
           message: "Declared Mesh folder missing",
           action: async () => {
-            await mkdir11(meshPath, { recursive: true });
+            await mkdir10(meshPath, { recursive: true });
           },
           actionLabel: `Create ${folder}`
         });
@@ -6573,7 +6073,7 @@ Describe the shard context here.
   }
   const checkFilePrefix = async (dir, prefix) => {
     try {
-      const entries = await readdir62(join14(shardPath, dir), { withFileTypes: true });
+      const entries = await readdir52(join13(shardPath, dir), { withFileTypes: true });
       for (const entry of entries) {
         if (entry.isFile() && entry.name.endsWith(".md") && !entry.name.startsWith(prefix)) {
           results.push({
@@ -6588,7 +6088,7 @@ Describe the shard context here.
   };
   const checkInstallNaming = async (shorthandValue) => {
     try {
-      const entries = await readdir62(join14(shardPath, "install"), { withFileTypes: true });
+      const entries = await readdir52(join13(shardPath, "install"), { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isFile()) continue;
         const expectedPrefix = entry.name.startsWith("type-") ? `type-${shorthandValue}-` : entry.name.startsWith("inst-") ? `inst-${shorthandValue}-` : null;
@@ -6639,7 +6139,7 @@ async function getShardInfo(flintPath, identifier) {
   const installed = await getInstalledShardsWithVersions(flintPath);
   const match = resolveInstalledShardInfo(installed, identifier);
   if (match) {
-    const shardPath = join14(flintPath, "Shards", match.folderName);
+    const shardPath = join13(flintPath, "Shards", match.folderName);
     const manifest = await readShardManifest(shardPath);
     const decl = declarations[match.name];
     return {
@@ -6651,10 +6151,10 @@ async function getShardInfo(flintPath, identifier) {
       dev: decl ? resolveShardMode(decl) === "dev" : false,
       mode: decl ? resolveShardMode(decl) || "normal" : "normal",
       folderName: match.folderName,
-      skillCount: await countFiles2(join14(shardPath, "skills")),
-      templateCount: await countFiles2(join14(shardPath, "templates")),
-      workflowCount: await countFiles2(join14(shardPath, "workflows")),
-      knowledgeCount: await countFiles2(join14(shardPath, "knowledge"))
+      skillCount: await countFiles2(join13(shardPath, "skills")),
+      templateCount: await countFiles2(join13(shardPath, "templates")),
+      workflowCount: await countFiles2(join13(shardPath, "workflows")),
+      knowledgeCount: await countFiles2(join13(shardPath, "knowledge"))
     };
   }
   return null;
@@ -6664,7 +6164,7 @@ async function findShardFolder(flintPath, identifier) {
   return resolveInstalledShardInfo(installed, identifier)?.folderName ?? null;
 }
 function getShardScriptsDir(flintPath, shardFolder) {
-  return join15(flintPath, "Shards", shardFolder, "scripts");
+  return join14(flintPath, "Shards", shardFolder, "scripts");
 }
 async function listShardScripts(flintPath, shardIdentifier) {
   const shardFolder = await findShardFolder(flintPath, shardIdentifier);
@@ -6673,14 +6173,14 @@ async function listShardScripts(flintPath, shardIdentifier) {
   }
   const scriptsDir = getShardScriptsDir(flintPath, shardFolder);
   try {
-    const entries = await readdir72(scriptsDir, { withFileTypes: true });
+    const entries = await readdir62(scriptsDir, { withFileTypes: true });
     const scripts = [];
     for (const entry of entries) {
       if (entry.isFile()) {
         const name = entry.name.replace(/\.[^.]+$/, "");
         scripts.push({
           name,
-          path: join15(scriptsDir, entry.name)
+          path: join14(scriptsDir, entry.name)
         });
       }
     }
@@ -6691,15 +6191,15 @@ async function listShardScripts(flintPath, shardIdentifier) {
 }
 async function findScript(scriptsDir, scriptName) {
   try {
-    const entries = await readdir72(scriptsDir);
+    const entries = await readdir62(scriptsDir);
     if (entries.includes(scriptName)) {
-      return join15(scriptsDir, scriptName);
+      return join14(scriptsDir, scriptName);
     }
     const extensions = [".sh", ".js", ".ts", ".mjs", ".py", ""];
     for (const ext of extensions) {
       const filename = scriptName + ext;
       if (entries.includes(filename)) {
-        return join15(scriptsDir, filename);
+        return join14(scriptsDir, filename);
       }
     }
     return null;
@@ -6749,11 +6249,11 @@ async function runShardScript(flintPath, shardIdentifier, scriptName, args = [])
     const scriptNames = available.map((s) => s.name).join(", ");
     throw new Error(`Script "${scriptName}" not found. Available: ${scriptNames}`);
   }
-  const resolvedFlintPath = resolve7(flintPath);
+  const resolvedFlintPath = resolve6(flintPath);
   const runner = await getScriptRunner(scriptPath);
   const fullArgs = [...runner.args, ...args];
-  return new Promise((resolve9, reject) => {
-    const child = spawn2(runner.command, fullArgs, {
+  return new Promise((resolve8, reject) => {
+    const child = spawn(runner.command, fullArgs, {
       cwd: resolvedFlintPath,
       env: {
         ...process.env,
@@ -6774,7 +6274,7 @@ async function runShardScript(flintPath, shardIdentifier, scriptName, args = [])
       reject(new Error(`Failed to run script: ${err.message}`));
     });
     child.on("close", (code) => {
-      resolve9({
+      resolve8({
         exitCode: code ?? 1,
         stdout: stdout.trim(),
         stderr: stderr.trim()
@@ -6848,23 +6348,23 @@ function buildSourcesEntries(config) {
 }
 async function shardHasGitRemote(shardPath) {
   try {
-    const configPath = join16(shardPath, ".git", "config");
-    const config = await readFile9(configPath, "utf-8");
+    const configPath = join15(shardPath, ".git", "config");
+    const config = await readFile8(configPath, "utf-8");
     return config.includes("[remote");
   } catch {
     return false;
   }
 }
 async function buildShardEntries(flintPath) {
-  const shardsDir = join16(flintPath, "Shards");
+  const shardsDir = join15(flintPath, "Shards");
   if (!await exists(shardsDir)) return [];
   const entries = [];
   try {
-    const folders = await readdir82(shardsDir, { withFileTypes: true });
+    const folders = await readdir72(shardsDir, { withFileTypes: true });
     for (const folder of folders) {
       if (!folder.isDirectory() || folder.name.startsWith("(System)")) continue;
-      const gitDir = join16(shardsDir, folder.name, ".git");
-      if (await exists(gitDir) && await shardHasGitRemote(join16(shardsDir, folder.name))) {
+      const gitDir = join15(shardsDir, folder.name, ".git");
+      if (await exists(gitDir) && await shardHasGitRemote(join15(shardsDir, folder.name))) {
         entries.push(`Shards/${folder.name}/`);
       }
     }
@@ -6877,10 +6377,10 @@ function formatManagedContent(sections) {
 ${section.entries.join("\n")}`).join("\n\n");
 }
 async function createGitignore(flintPath) {
-  const gitignorePath = join16(flintPath, ".gitignore");
+  const gitignorePath = join15(flintPath, ".gitignore");
   const sections = await buildGitignoreEntries(flintPath);
   const content = formatManagedContent(sections);
-  await writeFile10(
+  await writeFile9(
     gitignorePath,
     `${MANAGED_SECTION_START}
 ${content}
@@ -6889,10 +6389,10 @@ ${MANAGED_SECTION_END}
   );
 }
 async function updateGitignore(flintPath) {
-  const gitignorePath = join16(flintPath, ".gitignore");
+  const gitignorePath = join15(flintPath, ".gitignore");
   let existing = "";
   try {
-    existing = await readFile9(gitignorePath, "utf-8");
+    existing = await readFile8(gitignorePath, "utf-8");
   } catch {
     await createGitignore(flintPath);
     return;
@@ -6911,15 +6411,15 @@ ${MANAGED_SECTION_END}`;
   } else {
     existing = existing.trim() + "\n\n" + managedSection + "\n";
   }
-  await writeFile10(gitignorePath, existing.trim() + "\n");
+  await writeFile9(gitignorePath, existing.trim() + "\n");
 }
 function escapeRegex(str) {
   return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-var execAsync5 = promisify6(exec5);
+var execAsync4 = promisify5(exec4);
 async function isGitInitialized(flintPath) {
   try {
-    await execAsync5("git rev-parse --git-dir", { cwd: flintPath });
+    await execAsync4("git rev-parse --git-dir", { cwd: flintPath });
     return true;
   } catch {
     return false;
@@ -6927,7 +6427,7 @@ async function isGitInitialized(flintPath) {
 }
 async function initGit(flintPath) {
   try {
-    await execAsync5("git init", { cwd: flintPath });
+    await execAsync4("git init", { cwd: flintPath });
     await createGitignore(flintPath);
     return { success: true, output: "Git initialized with .gitignore" };
   } catch (err) {
@@ -6950,10 +6450,10 @@ async function getGitStatus(flintPath) {
     };
   }
   try {
-    const { stdout: branchOut } = await execAsync5("git branch --show-current", {
+    const { stdout: branchOut } = await execAsync4("git branch --show-current", {
       cwd: flintPath
     });
-    const { stdout: statusOut } = await execAsync5("git status --porcelain", {
+    const { stdout: statusOut } = await execAsync4("git status --porcelain", {
       cwd: flintPath
     });
     const lines = statusOut.trim().split("\n").filter(Boolean);
@@ -6995,7 +6495,7 @@ async function runGit(flintPath, args, options) {
     const quotedArgs = args.map(
       (arg) => arg.includes(" ") ? `"${arg}"` : arg
     );
-    const { stdout, stderr } = await execAsync5(`git ${quotedArgs.join(" ")}`, {
+    const { stdout, stderr } = await execAsync4(`git ${quotedArgs.join(" ")}`, {
       cwd: flintPath,
       env: options?.env ? { ...process.env, ...options.env } : void 0
     });
@@ -7072,11 +6572,11 @@ async function isRebaseInProgress(cwd) {
 async function getRebaseBranch(cwd) {
   const result = await runGit(cwd, ["rev-parse", "--git-path", "rebase-merge/head-name"]);
   if (result.success) {
-    const { readFile: readFile11 } = await import("fs/promises");
+    const { readFile: readFile10 } = await import("fs/promises");
     const path = await import("path");
     const headNamePath = path.resolve(cwd, result.output.trim());
     try {
-      const ref = (await readFile11(headNamePath, "utf-8")).trim();
+      const ref = (await readFile10(headNamePath, "utf-8")).trim();
       return ref.replace(/^refs\/heads\//, "");
     } catch {
     }
@@ -7091,7 +6591,7 @@ async function getConflictFiles(cwd) {
   return [];
 }
 async function hasConflictMarkers(cwd, files) {
-  const { readFile: readFile11 } = await import("fs/promises");
+  const { readFile: readFile10 } = await import("fs/promises");
   const path = await import("path");
   let filesToCheck = files;
   if (!filesToCheck || filesToCheck.length === 0) {
@@ -7110,7 +6610,7 @@ async function hasConflictMarkers(cwd, files) {
   const conflicted = [];
   for (const file of filesToCheck) {
     try {
-      const content = await readFile11(path.resolve(cwd, file), "utf-8");
+      const content = await readFile10(path.resolve(cwd, file), "utf-8");
       if (content.includes("<<<<<<<") && content.includes("=======") && content.includes(">>>>>>>")) {
         conflicted.push(file);
       }
@@ -7147,10 +6647,10 @@ async function syncFlint(flintPath, progress) {
   };
   const flintConfigDir = getFlintConfigDir(flintPath);
   try {
-    await stat82(flintConfigDir);
+    await stat72(flintConfigDir);
   } catch {
     try {
-      await mkdir12(flintConfigDir, { recursive: true });
+      await mkdir11(flintConfigDir, { recursive: true });
       result.bootstrap.created = true;
     } catch (err) {
       result.errors.push({
@@ -7160,11 +6660,11 @@ async function syncFlint(flintPath, progress) {
     }
   }
   for (const dir of STANDARD_DIRECTORIES) {
-    const dirPath = join17(flintPath, dir);
+    const dirPath = join16(flintPath, dir);
     try {
-      await stat82(dirPath);
+      await stat72(dirPath);
     } catch {
-      await mkdir12(dirPath, { recursive: true });
+      await mkdir11(dirPath, { recursive: true });
       result.bootstrap.directories.push(dir);
     }
   }
@@ -7183,9 +6683,9 @@ async function syncFlint(flintPath, progress) {
       error: `Failed to sync metadata: ${err instanceof Error ? err.message : String(err)}`
     });
   }
-  const obsidianDir = join17(flintPath, ".obsidian");
+  const obsidianDir = join16(flintPath, ".obsidian");
   try {
-    await stat82(obsidianDir);
+    await stat72(obsidianDir);
     result.obsidian.existed = true;
   } catch {
     try {
@@ -7209,8 +6709,8 @@ async function syncFlint(flintPath, progress) {
   const shardsToUninstall = installedShards.filter((s) => !requiredShardSet.has(s.name)).map((s) => s.name);
   {
     const { exec: execCb } = await import("child_process");
-    const { promisify: promisify7 } = await import("util");
-    const execAsync6 = promisify7(execCb);
+    const { promisify: promisify6 } = await import("util");
+    const execAsync5 = promisify6(execCb);
     const shardTasks = [];
     for (const kebabName of shardsToInstall) {
       const declaration = shardDeclarations[kebabName];
@@ -7233,9 +6733,9 @@ async function syncFlint(flintPath, progress) {
               throw new Error(`Dev shard source is not a GitHub source: ${source}`);
             }
             const folderName = `(Dev) ${kebabName.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ")}`;
-            const devPath = join17(flintPath, "Shards", folderName);
+            const devPath = join16(flintPath, "Shards", folderName);
             const cloneUrl = `https://github.com/${parsed.owner}/${parsed.repo}.git`;
-            await execAsync6(`git clone "${cloneUrl}" "${devPath}"`, { timeout: 6e4 });
+            await execAsync5(`git clone "${cloneUrl}" "${devPath}"`, { timeout: 6e4 });
             await pullShard(flintPath, folderName, { force: true });
           }
         });
@@ -7292,28 +6792,28 @@ async function syncFlint(flintPath, progress) {
     }
   }
   const requiredMeshExports = config.sources?.meshexports || [];
-  const { getFlintRegistry: getFlintRegistry2 } = await import("./registry-YN5W7EY7-J52KXGG5.js");
-  const { readdir: readdir10, readFile: fsReadFile, rm: rm8, stat: fsStat, mkdir: fsMkdir, copyFile: fsCopyFile } = await import("fs/promises");
-  const { syncSourceMeshExportMetadata: syncSourceMeshExportMetadata2 } = await import("./metadata-SJT4H53O-LEFHYM5Q.js");
+  const { getFlintRegistry: getFlintRegistry2 } = await import("./registry-5CNUVQN3-PCQZRXLB.js");
+  const { readdir: readdir9, readFile: fsReadFile, rm: rm7, stat: fsStat, mkdir: fsMkdir, copyFile: fsCopyFile } = await import("fs/promises");
+  const { syncSourceMeshExportMetadata: syncSourceMeshExportMetadata2 } = await import("./metadata-FASTWX6A-ITKM6C62.js");
   const requiredMeshExportSet = new Set(requiredMeshExports);
-  const sourcesFlintDir = join17(flintPath, "Sources", "Flints");
+  const sourcesFlintDir = join16(flintPath, "Sources", "Flints");
   try {
-    const flintFolders = await readdir10(sourcesFlintDir, { withFileTypes: true });
+    const flintFolders = await readdir9(sourcesFlintDir, { withFileTypes: true });
     for (const flintFolder of flintFolders) {
       if (!flintFolder.isDirectory()) continue;
       const flintFolderName = flintFolder.name;
       const flintName = flintFolderName.replace(/^\(Flint\)\s*/, "");
-      const flintSourcePath = join17(sourcesFlintDir, flintFolderName);
-      const exportFolders = await readdir10(flintSourcePath, { withFileTypes: true });
+      const flintSourcePath = join16(sourcesFlintDir, flintFolderName);
+      const exportFolders = await readdir9(flintSourcePath, { withFileTypes: true });
       for (const exportFolder of exportFolders) {
         if (!exportFolder.isDirectory()) continue;
         const exportFolderName = exportFolder.name;
         const exportName = exportFolderName.replace(/^\(Mesh Export\)\s*/, "");
         const ref = `${flintName}/${exportName}`;
         if (!requiredMeshExportSet.has(ref)) {
-          const exportPath = join17(flintSourcePath, exportFolderName);
+          const exportPath = join16(flintSourcePath, exportFolderName);
           try {
-            await rm8(exportPath, { recursive: true });
+            await rm7(exportPath, { recursive: true });
             result.meshexports.push({ ref, status: "removed" });
           } catch (err) {
             result.meshexports.push({
@@ -7324,10 +6824,10 @@ async function syncFlint(flintPath, progress) {
           }
         }
       }
-      const remaining = await readdir10(flintSourcePath);
+      const remaining = await readdir9(flintSourcePath);
       if (remaining.length === 0) {
         try {
-          await rm8(flintSourcePath, { recursive: true });
+          await rm7(flintSourcePath, { recursive: true });
         } catch {
         }
       }
@@ -7336,7 +6836,7 @@ async function syncFlint(flintPath, progress) {
   }
   if (requiredMeshExports.length > 0) {
     const registry = await getFlintRegistry2();
-    const { buildExportByName: buildExportByName2, scanExports: scanExports2 } = await import("./exports-FO5IMLM7-4DUGQDXH.js");
+    const { buildExportByName: buildExportByName2, scanExports: scanExports2 } = await import("./exports-VR7XB6MC-5N77WY3S.js");
     for (const ref of requiredMeshExports) {
       const parts = ref.split("/");
       if (parts.length !== 2) {
@@ -7353,7 +6853,7 @@ async function syncFlint(flintPath, progress) {
         return simpleName === flintName || f.name === flintName;
       });
       if (!sourceFlint) {
-        const destDir2 = join17(flintPath, "Sources", "Flints", `(Flint) ${flintName}`, `(Mesh Export) ${exportName}`);
+        const destDir2 = join16(flintPath, "Sources", "Flints", `(Flint) ${flintName}`, `(Mesh Export) ${exportName}`);
         try {
           await fsStat(destDir2);
           result.meshexports.push({ ref, status: "unavailable" });
@@ -7381,34 +6881,34 @@ async function syncFlint(flintPath, progress) {
         });
         continue;
       }
-      const exportDir = join17(sourceFlint.path, "Exports", `(Mesh Export) ${exportName}`);
-      const destDir = join17(flintPath, "Sources", "Flints", `(Flint) ${flintName}`, `(Mesh Export) ${exportName}`);
+      const exportDir = join16(sourceFlint.path, "Exports", `(Mesh Export) ${exportName}`);
+      const destDir = join16(flintPath, "Sources", "Flints", `(Flint) ${flintName}`, `(Mesh Export) ${exportName}`);
       try {
         try {
-          await rm8(destDir, { recursive: true });
+          await rm7(destDir, { recursive: true });
         } catch {
         }
         let fileCount = 0;
-        const meshSourceDir = join17(exportDir, "Mesh");
-        const meshDestDir = join17(destDir, "Mesh");
+        const meshSourceDir = join16(exportDir, "Mesh");
+        const meshDestDir = join16(destDir, "Mesh");
         try {
           await fsStat(meshSourceDir);
           await fsMkdir(meshDestDir, { recursive: true });
-          const meshFiles = await readdir10(meshSourceDir);
+          const meshFiles = await readdir9(meshSourceDir);
           for (const file of meshFiles) {
-            await fsCopyFile(join17(meshSourceDir, file), join17(meshDestDir, file));
+            await fsCopyFile(join16(meshSourceDir, file), join16(meshDestDir, file));
             fileCount++;
           }
         } catch {
         }
-        const mediaSourceDir = join17(exportDir, "Media");
-        const mediaDestDir = join17(destDir, "Media");
+        const mediaSourceDir = join16(exportDir, "Media");
+        const mediaDestDir = join16(destDir, "Media");
         try {
           await fsStat(mediaSourceDir);
           await fsMkdir(mediaDestDir, { recursive: true });
-          const mediaFiles = await readdir10(mediaSourceDir);
+          const mediaFiles = await readdir9(mediaSourceDir);
           for (const file of mediaFiles) {
-            await fsCopyFile(join17(mediaSourceDir, file), join17(mediaDestDir, file));
+            await fsCopyFile(join16(mediaSourceDir, file), join16(mediaDestDir, file));
             fileCount++;
           }
         } catch {
@@ -7480,10 +6980,23 @@ async function syncFlint(flintPath, progress) {
       error: `Failed to sync source repo metadata: ${err instanceof Error ? err.message : String(err)}`
     });
   }
-  const { getPlateDeclarationsFromConfig } = await import("./mesh-config-BAIYF4KD-Q3ZCQOCZ.js");
+  const { getPlateDeclarationsFromConfig } = await import("./mesh-config-NTGFUNZL-BZ2GO3JY.js");
   const plateDeclarations = getPlateDeclarationsFromConfig(config);
+  const hasSourcePlates = Object.values(plateDeclarations).some((d) => d.source);
   const hasRepoPlates = Object.values(plateDeclarations).some((d) => d.repo);
-  if (hasRepoPlates) {
+  if (hasSourcePlates) {
+    const { syncDeclaredPlates: syncDeclaredPlates2 } = await import("./plates-UD55BGK4-HV7L7MQX.js");
+    const plateResults = await syncDeclaredPlates2(flintPath, plateDeclarations);
+    result.plates = plateResults;
+    for (const pr of plateResults) {
+      if (pr.status === "error") {
+        result.errors.push({
+          name: `plate:${pr.name}`,
+          error: pr.error || "Unknown error"
+        });
+      }
+    }
+  } else if (hasRepoPlates) {
     const plateResults = await syncPlateRepos(flintPath, plateDeclarations);
     result.plates = plateResults;
     for (const pr of plateResults) {
@@ -7500,11 +7013,11 @@ async function syncFlint(flintPath, progress) {
   if (tomlName) {
     try {
       const registryEntry = await findFlintByPath(flintPath);
-      const currentFolderName = basename4(flintPath);
+      const currentFolderName = basename3(flintPath);
       const expectedFolderName = `(Flint) ${tomlName}`;
       if (currentFolderName !== expectedFolderName) {
         const parentDir = dirname5(flintPath);
-        const newPath = join17(parentDir, expectedFolderName);
+        const newPath = join16(parentDir, expectedFolderName);
         try {
           await rename32(flintPath, newPath);
           currentFlintPath = newPath;
@@ -7550,11 +7063,11 @@ async function syncFlint(flintPath, progress) {
       console.warn(`Registry sync warning: ${err instanceof Error ? err.message : String(err)}`);
     }
   }
-  const inboxDir = join17(currentFlintPath, "Inbox");
+  const inboxDir = join16(currentFlintPath, "Inbox");
   try {
-    const inboxEntries = await readdir10(inboxDir);
+    const inboxEntries = await readdir9(inboxDir);
     if (inboxEntries.length === 0) {
-      await rm8(inboxDir, { recursive: true });
+      await rm7(inboxDir, { recursive: true });
     }
   } catch {
   }
@@ -7583,23 +7096,23 @@ async function syncFlint(flintPath, progress) {
 var __dirname = dirname6(fileURLToPath(import.meta.url));
 var presetsCache = null;
 function getBuiltinPresetsDir() {
-  return join18(__dirname, "presets");
+  return join17(__dirname, "presets");
 }
 function getUserPresetsDir() {
-  return join18(getGlobalFlintDir(), "presets");
+  return join17(getGlobalFlintDir(), "presets");
 }
 function resolvePresetTarget(flintPath, targetPath) {
-  const resolvedRoot = resolve8(flintPath);
-  const resolvedTarget = resolve8(flintPath, targetPath);
+  const resolvedRoot = resolve7(flintPath);
+  const resolvedTarget = resolve7(flintPath, targetPath);
   if (!resolvedTarget.startsWith(resolvedRoot + sep)) {
     throw new Error(`Preset template target escapes flint root: ${targetPath}`);
   }
   return resolvedTarget;
 }
 async function loadPresetFromDir(presetDir) {
-  const tomlPath = join18(presetDir, "preset.toml");
+  const tomlPath = join17(presetDir, "preset.toml");
   try {
-    const content = await readFile10(tomlPath, "utf-8");
+    const content = await readFile9(tomlPath, "utf-8");
     const parsed = parse(content);
     return {
       name: parsed.preset.name,
@@ -7615,10 +7128,10 @@ async function loadPresetFromDir(presetDir) {
 async function discoverPresetsFromDir(presetsDir) {
   const presets = /* @__PURE__ */ new Map();
   try {
-    const entries = await readdir9(presetsDir, { withFileTypes: true });
+    const entries = await readdir82(presetsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
-      const presetDir = join18(presetsDir, entry.name);
+      const presetDir = join17(presetsDir, entry.name);
       const preset = await loadPresetFromDir(presetDir);
       if (preset) {
         presets.set(preset.name, preset);
@@ -7662,21 +7175,21 @@ async function hasPreset(name) {
 async function applyPresetTemplates(flintPath, preset, flintName) {
   for (const template of preset.templates) {
     const templateUuid = randomUUID4();
-    const sourcePath = join18(preset.basePath, template.source);
+    const sourcePath = join17(preset.basePath, template.source);
     const renderedTarget = template.target.replace(/\{\{name\}\}/g, flintName).replace(/\{\{uuid\}\}/g, templateUuid).replace(/\{\{date\}\}/g, (/* @__PURE__ */ new Date()).toISOString().split("T")[0]);
     const resolvedTargetPath = resolvePresetTarget(flintPath, renderedTarget);
-    await mkdir13(dirname6(resolvedTargetPath), { recursive: true });
-    let content = await readFile10(sourcePath, "utf-8");
+    await mkdir12(dirname6(resolvedTargetPath), { recursive: true });
+    let content = await readFile9(sourcePath, "utf-8");
     content = content.replace(/\{\{name\}\}/g, flintName).replace(/\{\{uuid\}\}/g, templateUuid).replace(/\{\{date\}\}/g, (/* @__PURE__ */ new Date()).toISOString().split("T")[0]);
-    const { writeFile: writeFile11 } = await import("fs/promises");
-    await writeFile11(resolvedTargetPath, content);
+    const { writeFile: writeFile10 } = await import("fs/promises");
+    await writeFile10(resolvedTargetPath, content);
   }
 }
 function getSessionsDir(flintPath) {
-  return join19(getFlintConfigDir(flintPath), "sessions");
+  return join18(flintPath, ".orbh", "sessions");
 }
 function getSessionPath(flintPath, sessionId) {
-  return join19(getSessionsDir(flintPath), `${sessionId}.json`);
+  return join18(getSessionsDir(flintPath), `${sessionId}.json`);
 }
 function ensureSessionsDir(flintPath) {
   const dir = getSessionsDir(flintPath);
@@ -7825,7 +7338,7 @@ function listSessions(flintPath) {
   const sessions = [];
   for (const file of files) {
     try {
-      const content = readFileSync2(join19(dir, file), "utf-8");
+      const content = readFileSync2(join18(dir, file), "utf-8");
       sessions.push(JSON.parse(content));
     } catch {
     }
@@ -8043,7 +7556,7 @@ function parseJsonl(text) {
 }
 function resolveTranscriptPath(cwd, nativeSessionId) {
   const sanitized = cwd.replace(/[^a-zA-Z0-9\-_]/g, "-");
-  return join20(homedir3(), ".claude", "projects", sanitized, `${nativeSessionId}.jsonl`);
+  return join19(homedir3(), ".claude", "projects", sanitized, `${nativeSessionId}.jsonl`);
 }
 var TranscriptWatcher = class {
   transcriptPath = null;
@@ -8384,19 +7897,6 @@ export {
   getConfigValue,
   setConfigValue,
   getOpenApps,
-  readPlateManifest,
-  initPlateRepo,
-  clonePlateFromRepo,
-  updatePlateFromRepo,
-  syncPlateRepos,
-  listPlates,
-  getPlate,
-  createPlate,
-  installPlateDeps,
-  buildPlate,
-  runPlateTool,
-  listPlateTools,
-  spawnPlateDevServer,
   getIdentityStatePath,
   getPersonFilePath,
   readIdentityState,
@@ -8436,7 +7936,7 @@ export {
   fulfillCodebase,
   fulfillFlint,
   unfulfill,
-  resolve3,
+  resolve2,
   getStatus,
   getUnfulfilled,
   getUnfulfilledCodebases,