@nuucognition/flint-cli 0.2.0-beta.1 → 0.2.0-beta.2

package/dist/index.js

@@ -41,7 +41,11 @@ import {
   toKebabCase,
   writeFlintJson,
   writeFlintToml
-} from "./chunk-5YLBX2W6.js";
+} from "./chunk-RAH2IR2Z.js";
+import {
+  exists,
+  runConcurrent
+} from "./chunk-V7YA5RXL.js";
 import {
   cleanRegistryFile,
   findFlintByName,
@@ -49,22 +53,23 @@ import {
   getFlintRegistry,
   getFlintRegistryPath,
   getGlobalFlintDir,
+  isFlintNameTaken,
   registerFlint,
   registerFlintByPath,
   unregisterFlint,
   updateFlintEntry,
   upsertFlintEntry
-} from "./chunk-UNMULXL5.js";
+} from "./chunk-VEO4E5HX.js";
 import {
   buildExport,
   cleanupStaleExports,
   scanExportEligible,
   scanExports
-} from "./chunk-VO4ZYDCW.js";
+} from "./chunk-K5QP4OME.js";
 
 // src/index.ts
-import { Command as Command30 } from "commander";
-import { readFileSync as readFileSync2, existsSync as existsSync6, cpSync, mkdirSync, readdirSync as readdirSync2 } from "fs";
+import { Command as Command29 } from "commander";
+import { readFileSync as readFileSync2, existsSync as existsSync7, cpSync, mkdirSync, readdirSync as readdirSync2 } from "fs";
 import { fileURLToPath as fileURLToPath5 } from "url";
 import { dirname as dirname10, join as join35 } from "path";
 import { homedir as homedir5 } from "os";
@@ -1376,7 +1381,6 @@ function createFeaturesCommand(config) {
 var FEATURES = createFeatureRegistry([
   // === Production Commands ===
   { id: "init", tier: "prod", type: "command", description: "Create a new flint workspace", requiresAuth: false },
-  { id: "clone", tier: "prod", type: "command", description: "Clone a flint from a git repository", requiresAuth: false },
   { id: "list", tier: "prod", type: "command", description: "List flints and mesh content", requiresAuth: false },
   { id: "sync", tier: "prod", type: "command", description: "Synchronize flint with shards", requiresAuth: false },
   { id: "shard", tier: "prod", type: "command", description: "Shard management", requiresAuth: false },
@@ -1404,19 +1408,24 @@ var FEATURES = createFeatureRegistry([
   // === Dev Commands ===
   { id: "lattice", tier: "dev", type: "command", description: "Lattice integration", requiresAuth: false },
   { id: "agent", tier: "dev", type: "command", description: "AI agent integration", requiresAuth: false },
-  { id: "code", tier: "dev", type: "command", description: "Launch AI coding agents", requiresAuth: false },
+  { id: "code", tier: "exp", type: "command", description: "Launch AI coding agents", requiresAuth: false },
   { id: "server", tier: "dev", type: "command", description: "Flint runtime server", requiresAuth: false },
   { id: "runtime", tier: "dev", type: "command", description: "Flint runtime management", requiresAuth: false },
-  { id: "completions", tier: "dev", type: "command", description: "Shell completions", requiresAuth: false },
   { id: "obsidian.push", tier: "dev", type: "function", description: "Push obsidian config changes to remote", requiresAuth: false },
   { id: "agent.start", tier: "dev", type: "function", description: "Start AI agent session", requiresAuth: false }
 ]);
 
 // src/commands/init.ts
 import { Command as Command3 } from "commander";
-import pc5 from "picocolors";
-import { execSync as execSync5 } from "child_process";
+import pc6 from "picocolors";
+import { execSync as execSync2 } from "child_process";
 import { platform as platform2 } from "os";
+import { resolve as resolve8, join as join19 } from "path";
+import { existsSync as existsSync2 } from "fs";
+import { mkdtemp as mkdtemp3, rm as rm8, rename as rename4 } from "fs/promises";
+import { tmpdir as tmpdir3 } from "os";
+import { exec as exec6 } from "child_process";
+import { promisify as promisify7 } from "util";
 
 // ../../packages/flint/dist/index.js
 import { mkdir as mkdir4, stat as stat22 } from "fs/promises";
@@ -1425,40 +1434,42 @@ import { join as join9, dirname as dirname4, basename } from "path";
 import { stat as stat32 } from "fs/promises";
 import { dirname as dirname22, join as join33 } from "path";
 import { join as join42 } from "path";
-import { execSync } from "child_process";
+import { exec } from "child_process";
+import { promisify as promisify6 } from "util";
 import { readdir as readdir4, stat as stat42, access as access2 } from "fs/promises";
 import { join as join52, resolve } from "path";
 import { homedir as homedir3 } from "os";
 import { readFile as readFile4, writeFile as writeFile23, mkdir as mkdir33, stat as stat52, unlink as unlink3, access as access22 } from "fs/promises";
 import { join as join62 } from "path";
-import { exec } from "child_process";
-import { promisify as promisify6 } from "util";
+import { exec as exec2 } from "child_process";
+import { promisify as promisify22 } from "util";
 import { rm as rm5 } from "fs/promises";
 import { mkdir as mkdir5, readdir as readdir32, copyFile, rm as rm32, readFile as readFile32, writeFile as writeFile32, rmdir } from "fs/promises";
 import { join as join92, resolve as resolve3, dirname as dirname32 } from "path";
 import { randomUUID } from "crypto";
 import { parse as parseYaml2 } from "yaml";
-import { access as access3 } from "fs/promises";
 import { join as join82, resolve as resolve2, isAbsolute } from "path";
 import { mkdtemp, rm as rm22 } from "fs/promises";
 import { tmpdir } from "os";
-import { execSync as execSync2 } from "child_process";
+import { exec as exec3 } from "child_process";
+import { promisify as promisify32 } from "util";
 import { parse as parseYaml } from "yaml";
 import { readFile as readFile23 } from "fs/promises";
 import { join as join10 } from "path";
 import { readdir as readdir42, mkdir as mkdir6 } from "fs/promises";
 import { writeFile as writeFile4 } from "fs/promises";
 import { spawn } from "child_process";
-import { readdir as readdir5, access as access4, constants } from "fs/promises";
+import { readdir as readdir5, access as access3, constants } from "fs/promises";
 import { join as join11, resolve as resolve4 } from "path";
 import { mkdir as mkdir7, readFile as readFile5, writeFile as writeFile5, rm as rm52, readdir as readdir6, copyFile as copyFile2 } from "fs/promises";
 import { join as join13, dirname as dirname42, resolve as resolve6, sep } from "path";
-import { execSync as execSync4 } from "child_process";
+import { execSync } from "child_process";
 import { randomUUID as randomUUID2 } from "crypto";
 import { join as join12, resolve as resolve5, isAbsolute as isAbsolute2 } from "path";
 import { mkdtemp as mkdtemp2, rm as rm42 } from "fs/promises";
 import { tmpdir as tmpdir2 } from "os";
-import { execSync as execSync3 } from "child_process";
+import { exec as exec4 } from "child_process";
+import { promisify as promisify42 } from "util";
 import { parse as parseYaml3 } from "yaml";
 import { readFile as readFile42 } from "fs/promises";
 
@@ -2459,16 +2470,16 @@ var __dirname2 = dirname2(fileURLToPath2(import.meta.url));
 // ../../packages/flint/dist/index.js
 import { rename as rename22 } from "fs/promises";
 import { basename as basename3, dirname as dirname6, join as join18 } from "path";
-import { readFile as readFile6, writeFile as writeFile6, mkdir as mkdir8, access as access5, rm as rm6 } from "fs/promises";
+import { readFile as readFile6, writeFile as writeFile6, mkdir as mkdir8, access as access4, rm as rm6 } from "fs/promises";
 import { join as join14 } from "path";
-import { exec as exec2 } from "child_process";
-import { promisify as promisify22 } from "util";
-import { readFile as readFile7, writeFile as writeFile7 } from "fs/promises";
+import { exec as exec5 } from "child_process";
+import { promisify as promisify52 } from "util";
+import { readFile as readFile7, writeFile as writeFile7, readdir as readdir7 } from "fs/promises";
 import { join as join15 } from "path";
 import { stat as stat8, mkdir as mkdir11 } from "fs/promises";
-import { mkdir as mkdir10, readdir as readdir8, rm as rm7, cp as cp3, rename as rename3, access as access6 } from "fs/promises";
+import { mkdir as mkdir10, readdir as readdir9, rm as rm7, cp as cp3, rename as rename3, access as access5 } from "fs/promises";
 import { join as join17 } from "path";
-import { readdir as readdir7, readFile as readFile8, mkdir as mkdir9 } from "fs/promises";
+import { readdir as readdir8, readFile as readFile8, mkdir as mkdir9 } from "fs/promises";
 import { join as join16, dirname as dirname5, resolve as resolve7, sep as sep2 } from "path";
 import { randomUUID as randomUUID3 } from "crypto";
 import { fileURLToPath as fileURLToPath3 } from "url";
@@ -2511,6 +2522,12 @@ async function createFlintStructure(options) {
   if (invalidChars.test(name)) {
     throw new Error(`Flint name contains invalid characters: ${name}`);
   }
+  if (register) {
+    const existing = await isFlintNameTaken(name);
+    if (existing) {
+      throw new Error(`A flint named "${name}" already exists at: ${existing.path}`);
+    }
+  }
   const folderName = formatFlintFolderName(name);
   const flintPath = join23(parentDir, folderName);
   try {
@@ -2571,10 +2588,11 @@ async function isInsideFlint(path3) {
   const flintRoot = await findFlintRoot(path3);
   return flintRoot !== null;
 }
+var execAsync = promisify6(exec);
 var OBSIDIAN_REPO_URL = "https://github.com/NUU-Cognition/flint-dot-obsidian.git";
 async function cloneObsidian(flintPath) {
   const obsidianDir = join42(flintPath, ".obsidian");
-  execSync(`git clone ${OBSIDIAN_REPO_URL} "${obsidianDir}"`, { stdio: "pipe" });
+  await execAsync(`git clone ${OBSIDIAN_REPO_URL} "${obsidianDir}"`, { timeout: 6e4 });
 }
 async function isValidFlint(path3) {
   try {
@@ -2676,7 +2694,7 @@ async function discoverFlints(options) {
   }
   return results;
 }
-var execAsync = promisify6(exec);
+var execAsync2 = promisify22(exec2);
 var LEGACY_WORKSPACE_CONFIG_FILENAME = "workspace.toml";
 function getWorkspaceReferencesDir(flintPath) {
   return join62(flintPath, "Workspace", "References");
@@ -2853,8 +2871,8 @@ async function createRepository(flintPath, name, url) {
   }
   await mkdir33(repoPath, { recursive: true });
   try {
-    await execAsync("git init", { cwd: repoPath });
-    await execAsync(`git remote add origin "${url}"`, { cwd: repoPath });
+    await execAsync2("git init", { cwd: repoPath });
+    await execAsync2(`git remote add origin "${url}"`, { cwd: repoPath });
   } catch (error3) {
     const message = error3 instanceof Error ? error3.message : String(error3);
     await rm5(repoPath, { recursive: true, force: true });
@@ -2870,7 +2888,7 @@ async function cloneRepository(flintPath, name, url) {
     throw new Error(`Repository folder already exists: ${repoPath}`);
   }
   try {
-    await execAsync(`git clone "${url}" "${repoPath}"`);
+    await execAsync2(`git clone "${url}" "${repoPath}"`);
   } catch (error3) {
     const message = error3 instanceof Error ? error3.message : String(error3);
     throw new Error(`Failed to clone repository: ${message}`);
@@ -2888,7 +2906,7 @@ async function removeRepositoryFolder(flintPath, name) {
 async function updateRepository(flintPath, name, url) {
   const repoPath = getRepositoryPath(flintPath, name);
   if (await pathExists(repoPath)) {
-    await execAsync("git pull", { cwd: repoPath });
+    await execAsync2("git pull", { cwd: repoPath });
     return repoPath;
   }
   return cloneRepository(flintPath, name, url);
@@ -2927,7 +2945,7 @@ async function cloneSourceRepository(flintPath, name, url) {
     throw new Error(`Source repository folder already exists: ${repoPath}`);
   }
   try {
-    await execAsync(`git clone --depth 1 "${url}" "${repoPath}"`);
+    await execAsync2(`git clone --depth 1 "${url}" "${repoPath}"`);
   } catch (error3) {
     const message = error3 instanceof Error ? error3.message : String(error3);
     throw new Error(`Failed to clone source repository: ${message}`);
@@ -3013,14 +3031,7 @@ async function migrateWorkspaceConfig(flintPath) {
   }
   return result;
 }
-async function exists(path3) {
-  try {
-    await access3(path3);
-    return true;
-  } catch {
-    return false;
-  }
-}
+var execAsync3 = promisify32(exec3);
 function isOwnerRepo(s) {
   return /^[a-zA-Z0-9_.-]+\/[a-zA-Z0-9_.-]+$/.test(s);
 }
@@ -3075,8 +3086,7 @@ async function resolveShardSource(source, flintPath) {
 async function cloneAndResolve(url, source) {
   const tempDir = await mkdtemp(join82(tmpdir(), "flint-shard-"));
   try {
-    execSync2(`git clone --depth 1 ${url} "${tempDir}"`, {
-      stdio: "pipe",
+    await execAsync3(`git clone --depth 1 ${url} "${tempDir}"`, {
       timeout: 6e4
       // 60 second timeout
     });
@@ -3141,40 +3151,10 @@ async function fetchRemoteShardVersion(source) {
   }
   return null;
 }
-var _installingDeps = /* @__PURE__ */ new Set();
-async function resolveDependency(flintPath, dep, installedNames, options = {}) {
-  if (!isOwnerRepo(dep)) return;
-  if (_installingDeps.has(dep)) return;
-  _installingDeps.add(dep);
-  try {
-    const declarations = await getShardDeclarations(flintPath);
-    const declValues = Object.values(declarations);
-    const alreadyDeclared = declValues.some((d) => d.source === dep);
-    if (alreadyDeclared) return;
-    const installedKebabSet = new Set(installedNames.map((f) => toKebabCase(f)));
-    const repoParts = dep.split("/");
-    const repoName = repoParts[1] || "";
-    const depKebab = repoName.startsWith("shard-") ? repoName.slice(6) : repoName;
-    if (depKebab && installedKebabSet.has(depKebab)) return;
-    const source = parseShardSource(dep);
-    const resolved = await resolveShardSource(source, flintPath);
-    try {
-      const manifestKebab = toKebabCase(resolved.manifest.name);
-      if (!installedKebabSet.has(manifestKebab)) {
-        await installShardFromSource(flintPath, resolved.path, resolved.manifest, {
-          force: options.force,
-          source: dep
-        });
-      }
-    } finally {
-      await cleanupResolvedSource(resolved);
-    }
-  } finally {
-    _installingDeps.delete(dep);
-  }
-}
 async function cloneShardRepos(flintPath, repos) {
-  const { execSync: execSync52 } = await import("child_process");
+  const { exec: exec62 } = await import("child_process");
+  const { promisify: promisify62 } = await import("util");
+  const execAsync62 = promisify62(exec62);
   const reposDir = join92(flintPath, "Shards", "(System) Repos");
   await mkdir5(reposDir, { recursive: true });
   const gitignorePath = join92(reposDir, ".gitignore");
@@ -3189,7 +3169,7 @@ async function cloneShardRepos(flintPath, repos) {
     const branchArgs = repo.branch ? ["--branch", repo.branch] : [];
     const args = ["clone", ...branchArgs, "--depth", "1", repo.url, repoPath];
     try {
-      execSync52(`git ${args.join(" ")}`, { stdio: "pipe" });
+      await execAsync62(`git ${args.join(" ")}`, { timeout: 6e4 });
     } catch (err) {
       console.warn(`Failed to clone repo "${repo.name}" from ${repo.url}`);
     }
@@ -3202,7 +3182,9 @@ async function removeShardRepos(flintPath, repos) {
   }
 }
 async function pullShardRepos(flintPath, repos) {
-  const { execSync: execSync52 } = await import("child_process");
+  const { exec: exec62 } = await import("child_process");
+  const { promisify: promisify62 } = await import("util");
+  const execAsync62 = promisify62(exec62);
   const reposDir = join92(flintPath, "Shards", "(System) Repos");
   for (const repo of repos) {
     const repoPath = join92(reposDir, repo.name);
@@ -3211,7 +3193,7 @@ async function pullShardRepos(flintPath, repos) {
       continue;
     }
     try {
-      execSync52("git pull", { cwd: repoPath, stdio: "pipe" });
+      await execAsync62("git pull", { cwd: repoPath, timeout: 3e4 });
     } catch {
       console.warn(`Failed to pull repo "${repo.name}"`);
     }
@@ -3278,12 +3260,6 @@ async function installShardFromSource(flintPath, sourcePath, manifest, options =
   if (!resolvedDestPath.startsWith(resolvedFlintPath)) {
     throw new Error("Invalid shard path: outside flint directory");
   }
-  if (manifest.depends?.length) {
-    const installed = await listInstalledShards(flintPath);
-    for (const dep of manifest.depends) {
-      await resolveDependency(flintPath, dep, installed, { force: options.force });
-    }
-  }
   await rm32(destPath, { recursive: true, force: true });
   await mkdir5(destPath, { recursive: true });
   const shardYamlSrc = join92(sourcePath, "shard.yaml");
@@ -3291,12 +3267,9 @@ async function installShardFromSource(flintPath, sourcePath, manifest, options =
   if (await exists(shardYamlSrc)) {
     await copyFile(shardYamlSrc, shardYamlDest);
   }
-  const copyFolderPath = join92(sourcePath, "copy");
-  const hasLegacyCopyDir = await exists(copyFolderPath);
-  const shardFilesSource = hasLegacyCopyDir ? copyFolderPath : sourcePath;
-  const skipFiles = hasLegacyCopyDir ? [] : ["shard.yaml", "README.md", "install", ".git", "scripts"];
-  await copyDir(shardFilesSource, destPath, skipFiles);
-  const scriptsSrc = join92(sourcePath, hasLegacyCopyDir ? "copy/scripts" : "scripts");
+  const skipFiles = ["shard.yaml", "README.md", "install", ".git", "scripts"];
+  await copyDir(sourcePath, destPath, skipFiles);
+  const scriptsSrc = join92(sourcePath, "scripts");
   if (await exists(scriptsSrc)) {
     await copyDir(scriptsSrc, join92(destPath, "scripts"));
   }
@@ -3322,7 +3295,7 @@ async function installShardFromSource(flintPath, sourcePath, manifest, options =
         continue;
       }
       if (await exists(destFilePath)) {
-        const mode = entry.mode ?? (entry.force ? "force" : "once");
+        const mode = entry.mode ?? "once";
         if (mode === "once") {
           continue;
         }
@@ -3405,77 +3378,95 @@ async function updateShards(flintPath, options = {}) {
       return mode === "dev" || mode === "custom";
     }).map(([k]) => k)
   );
-  const results = [];
-  for (const info2 of installed) {
-    if (localSet.has(info2.name)) continue;
-    const declaration = declarations[info2.name];
-    const source = declaration?.source;
-    if (!options.reinstall && source && isOwnerRepo(source)) {
-      const parsed2 = parseShardSource(source);
-      const remoteVersion = await fetchRemoteShardVersion(parsed2);
-      if (remoteVersion && remoteVersion === info2.version) {
-        results.push({
+  const updatableShards = installed.filter((info2) => !localSet.has(info2.name));
+  const updateTasks = updatableShards.map((info2) => ({
+    name: info2.folderName,
+    run: async () => {
+      const declaration = declarations[info2.name];
+      const source = declaration?.source;
+      if (!options.reinstall && source && isOwnerRepo(source)) {
+        const parsed2 = parseShardSource(source);
+        const remoteVersion = await fetchRemoteShardVersion(parsed2);
+        if (remoteVersion && remoteVersion === info2.version) {
+          return {
+            name: info2.folderName,
+            path: join92(flintPath, "Shards", info2.folderName),
+            status: "skipped",
+            localVersion: info2.version,
+            remoteVersion,
+            reason: "up to date"
+          };
+        }
+      }
+      const shardPath = join92(flintPath, "Shards", info2.folderName);
+      const manifest = await readShardManifest(shardPath);
+      if (manifest?.repos?.length) {
+        await pullShardRepos(flintPath, manifest.repos);
+      }
+      if (!source || !isOwnerRepo(source)) {
+        return {
           name: info2.folderName,
           path: join92(flintPath, "Shards", info2.folderName),
           status: "skipped",
           localVersion: info2.version,
-          remoteVersion,
-          reason: "up to date"
+          reason: "no source configured"
+        };
+      }
+      const parsed = parseShardSource(source);
+      let resolved = null;
+      try {
+        resolved = await resolveShardSource(parsed, flintPath);
+      } catch {
+        return {
+          name: info2.folderName,
+          path: join92(flintPath, "Shards", info2.folderName),
+          status: "failed",
+          localVersion: info2.version,
+          reason: "failed to resolve source"
+        };
+      }
+      try {
+        await installShardFromSource(flintPath, resolved.path, resolved.manifest, {
+          force: true,
+          source
         });
-        continue;
+        return {
+          name: info2.folderName,
+          path: join92(flintPath, "Shards", info2.folderName),
+          status: "updated",
+          localVersion: info2.version,
+          remoteVersion: resolved.manifest.version
+        };
+      } catch {
+        return {
+          name: info2.folderName,
+          path: join92(flintPath, "Shards", info2.folderName),
+          status: "failed",
+          localVersion: info2.version,
+          reason: "failed to install from source"
+        };
+      } finally {
+        await cleanupResolvedSource(resolved);
       }
     }
-    const shardPath = join92(flintPath, "Shards", info2.folderName);
-    const manifest = await readShardManifest(shardPath);
-    if (manifest?.repos?.length) {
-      await pullShardRepos(flintPath, manifest.repos);
-    }
-    if (!source || !isOwnerRepo(source)) {
-      results.push({
-        name: info2.folderName,
-        path: join92(flintPath, "Shards", info2.folderName),
-        status: "skipped",
-        localVersion: info2.version,
-        reason: "no source configured"
-      });
-      continue;
-    }
-    const parsed = parseShardSource(source);
-    let resolved = null;
-    try {
-      resolved = await resolveShardSource(parsed, flintPath);
-    } catch {
-      results.push({
-        name: info2.folderName,
-        path: join92(flintPath, "Shards", info2.folderName),
-        status: "failed",
-        localVersion: info2.version,
-        reason: "failed to resolve source"
-      });
-      continue;
-    }
-    try {
-      await installShardFromSource(flintPath, resolved.path, resolved.manifest, {
-        force: true,
-        source
-      });
-      results.push({
-        name: info2.folderName,
-        path: join92(flintPath, "Shards", info2.folderName),
-        status: "updated",
-        localVersion: info2.version,
-        remoteVersion: resolved.manifest.version
-      });
-    } catch {
+  }));
+  const { runConcurrent: runConcurrent2 } = await import("./utils-BBA2XQZO-YU5SL3JY.js");
+  const concurrentResults = await runConcurrent2(updateTasks, {
+    concurrency: 5,
+    onStart: options.onStart,
+    onComplete: options.onComplete,
+    onError: options.onError
+  });
+  const results = concurrentResults.filter((r) => r.status === "ok" && r.value).map((r) => r.value);
+  for (const r of concurrentResults) {
+    if (r.status === "error") {
       results.push({
-        name: info2.folderName,
-        path: join92(flintPath, "Shards", info2.folderName),
+        name: r.name,
+        path: join92(flintPath, "Shards", r.name),
         status: "failed",
-        localVersion: info2.version,
-        reason: "failed to install from source"
+        localVersion: "",
+        reason: r.error?.message || "Unknown error"
       });
-    } finally {
-      await cleanupResolvedSource(resolved);
     }
   }
   return results;
@@ -3571,7 +3562,7 @@ async function pullShard(flintPath, identifier, options) {
     if (!manifest) continue;
     const result = { name: folder, reposCloned: 0, reposPulled: 0, foldersCreated: 0, filesInstalled: 0 };
     if (manifest.repos?.length) {
-      const { execSync: execSync52 } = await import("child_process");
+      const { execSync: execSync22 } = await import("child_process");
       const reposDir = join92(flintPath, "Shards", "(System) Repos");
       await mkdir5(reposDir, { recursive: true });
       const gitignorePath = join92(reposDir, ".gitignore");
@@ -3582,7 +3573,7 @@ async function pullShard(flintPath, identifier, options) {
         const repoPath = join92(reposDir, repo.name);
         if (await exists(repoPath)) {
           try {
-            execSync52("git pull", { cwd: repoPath, stdio: "pipe" });
+            execSync22("git pull", { cwd: repoPath, stdio: "pipe" });
             result.reposPulled++;
           } catch {
             console.warn(`Failed to pull repo "${repo.name}"`);
@@ -3591,7 +3582,7 @@ async function pullShard(flintPath, identifier, options) {
           const branchArgs = repo.branch ? ["--branch", repo.branch] : [];
           const args = ["clone", ...branchArgs, "--depth", "1", repo.url, repoPath];
           try {
-            execSync52(`git ${args.join(" ")}`, { stdio: "pipe" });
+            execSync22(`git ${args.join(" ")}`, { stdio: "pipe" });
             result.reposCloned++;
           } catch {
             console.warn(`Failed to clone repo "${repo.name}" from ${repo.url}`);
@@ -3620,7 +3611,7 @@ async function pullShard(flintPath, identifier, options) {
           const resolvedDestFilePath = resolve3(destFilePath);
           if (!resolvedDestFilePath.startsWith(resolvedFlintPath)) continue;
           if (await exists(destFilePath)) {
-            const mode = entry.mode ?? (entry.force ? "force" : "once");
+            const mode = entry.mode ?? "once";
             if (!options?.force && mode === "once") continue;
           }
           let content;
@@ -3761,6 +3752,10 @@ State for the ${name} shard.
 `;
     await writeFile32(join92(stateDir, `(Shard) ${name}.md`), stateContent);
   }
+  if (shardMode === "dev") {
+    const { execSync: execSync22 } = await import("child_process");
+    execSync22("git init", { cwd: shardPath, stdio: "pipe" });
+  }
   await addShardToConfig(flintPath, folderName, `path:./Shards/${folderName}`, { mode: shardMode });
   return { name: folderName, path: shardPath };
 }
@@ -3795,24 +3790,121 @@ async function registerExistingShard(flintPath, folderName) {
     path: shardPath
   };
 }
-function repoToKebab(dep) {
-  const parts = dep.split("/");
-  if (parts.length !== 2 || !parts[1]) return null;
-  const repo = parts[1];
-  return repo.startsWith("shard-") ? repo.slice(6) : repo;
+async function editShard(flintPath, folderName, source) {
+  const { execSync: execSync22 } = await import("child_process");
+  const { rename: rename32 } = await import("fs/promises");
+  const shardPath = join92(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 already a dev shard.`);
+  }
+  if (folderName.startsWith("(Custom)")) {
+    throw new Error(`"${folderName}" is a custom shard. Custom shards cannot be transitioned to dev mode.`);
+  }
+  const baseName = folderName.replace(/^\([^)]*\)\s*/, "");
+  const devFolderName = `(Dev) ${baseName}`;
+  const devPath = join92(flintPath, "Shards", devFolderName);
+  if (await exists(devPath)) {
+    throw new Error(`Dev folder already exists: Shards/${devFolderName}`);
+  }
+  await rename32(shardPath, devPath);
+  if (isOwnerRepo(source)) {
+    const tmpDir = join92(flintPath, ".flint", "_tmp_edit_" + Date.now());
+    try {
+      execSync22(`git clone --depth 1 "${source.includes("github.com") ? source : `https://github.com/${source}.git`}" "${tmpDir}"`, { stdio: "pipe", timeout: 6e4 });
+      await copyDir(join92(tmpDir, ".git"), join92(devPath, ".git"));
+    } catch {
+      execSync22("git init", { cwd: devPath, stdio: "pipe" });
+    } finally {
+      await rm32(tmpDir, { recursive: true, force: true });
+    }
+  } else {
+    execSync22("git init", { cwd: devPath, stdio: "pipe" });
+  }
+  const kebab = toKebabCase(folderName);
+  await removeShardFromConfig(flintPath, kebab);
+  await addShardToConfig(flintPath, devFolderName, isOwnerRepo(source) ? source : `path:./Shards/${devFolderName}`, { mode: "dev" });
+  return { name: devFolderName, path: devPath, oldFolder: folderName };
 }
-function isDepInstalled(dep, installedKebabSet, installedFolders, declarations) {
-  if (isOwnerRepo(dep)) {
-    if (Object.values(declarations).some((d) => d.source === dep)) {
-      return true;
+async function freezeShard(flintPath, folderName) {
+  const { execSync: execSync22 } = await import("child_process");
+  const { rename: rename32 } = await import("fs/promises");
+  const shardPath = join92(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 = join92(shardPath, ".git");
+  if (!await exists(gitDir)) {
+    throw new Error(`"${folderName}" has no .git directory.`);
+  }
+  try {
+    const status = execSync22("git status --porcelain", { cwd: shardPath, encoding: "utf-8" }).trim();
+    if (status) {
+      throw new Error(`"${folderName}" has uncommitted changes. Commit or stash them first.`);
     }
-    const kebab = repoToKebab(dep);
-    if (kebab && installedKebabSet.has(kebab)) {
-      return true;
+  } catch (err) {
+    if (err instanceof Error && err.message.includes("uncommitted changes")) throw err;
+  }
+  try {
+    const remote = execSync22("git remote get-url origin", { cwd: shardPath, encoding: "utf-8" }).trim();
+    if (remote) {
+      const unpushed = execSync22("git log @{u}..HEAD --oneline", { cwd: shardPath, encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+      if (unpushed) {
+        throw new Error(`"${folderName}" has unpushed commits. Push them first.`);
+      }
     }
-    return false;
+  } catch (err) {
+    if (err instanceof Error && err.message.includes("unpushed commits")) throw err;
+  }
+  const declarations = await getShardDeclarations(flintPath);
+  const kebab = toKebabCase(folderName);
+  const decl = declarations[kebab];
+  const source = decl?.source || "";
+  const baseName = folderName.replace(/^\(Dev\)\s*/, "");
+  const normalPath = join92(flintPath, "Shards", baseName);
+  if (await exists(normalPath)) {
+    throw new Error(`Normal folder already exists: Shards/${baseName}`);
+  }
+  await rm32(gitDir, { recursive: true, force: true });
+  await rename32(shardPath, normalPath);
+  await removeShardFromConfig(flintPath, kebab);
+  const normalSource = isOwnerRepo(source) ? source : `path:./Shards/${baseName}`;
+  await addShardToConfig(flintPath, baseName, normalSource);
+  return { name: baseName, path: normalPath, oldFolder: folderName };
+}
+async function addShardGitRemote(flintPath, folderName, url) {
+  const { execSync: execSync22 } = await import("child_process");
+  const shardPath = join92(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 = join92(shardPath, ".git");
+  if (!await exists(gitDir)) {
+    throw new Error(`"${folderName}" has no .git directory. Run git init first.`);
+  }
+  try {
+    const existing = execSync22("git remote get-url origin", { cwd: shardPath, encoding: "utf-8" }).trim();
+    if (existing) {
+      throw new Error(`"${folderName}" already has a remote: ${existing}. Use \`git remote set-url origin <url>\` to change it.`);
+    }
+  } catch (err) {
+    if (err instanceof Error && err.message.includes("already has a remote")) throw err;
   }
-  return installedKebabSet.has(dep) || installedFolders.some((f) => toKebabCase(f) === dep);
+  execSync22(`git remote add origin "${url}"`, { cwd: shardPath, stdio: "pipe" });
+  const match = url.match(/(?:github\.com[/:])([\w.-]+\/[\w.-]+?)(?:\.git)?$/);
+  const ownerRepo = match?.[1] || url;
+  const kebab = toKebabCase(folderName);
+  await removeShardFromConfig(flintPath, kebab);
+  await addShardToConfig(flintPath, folderName, ownerRepo, { mode: "dev" });
+  return { ownerRepo };
 }
 async function countFiles(dirPath) {
   try {
@@ -3882,12 +3974,11 @@ async function checkShardHealth(flintPath) {
         action: async () => {
           const name = folder.replace(/^\([^)]*\)\s*/, "");
           const shorthand = name.toLowerCase().replace(/\s+/g, "").slice(0, 4);
-          const yaml = `version: "0.1.0"
+          const yaml = `shard-spec: "0.1.0"
+version: "0.1.0"
 name: ${name}
 shorthand: ${shorthand}
 description: ${name} shard
-depends:
-  - core
 `;
           await writeFile4(join10(shardPath, "shard.yaml"), yaml);
         },
@@ -3929,36 +4020,6 @@ depends:
       }
     }
   }
-  const shardDeclarations = await getShardDeclarations(flintPath);
-  for (const folder of installedFolders) {
-    const shardPath = join10(flintPath, "Shards", folder);
-    const manifest = await readShardManifest(shardPath);
-    if (manifest?.depends) {
-      for (const dep of manifest.depends) {
-        const depInstalled = isDepInstalled(dep, installedKebabSet, installedFolders, shardDeclarations);
-        if (!depInstalled) {
-          const healAction = isOwnerRepo(dep) ? {
-            action: async () => {
-              const source = parseShardSource(dep);
-              const resolved = await resolveShardSource(source, flintPath);
-              try {
-                await installShardFromSource(flintPath, resolved.path, resolved.manifest, { source: dep });
-              } finally {
-                await cleanupResolvedSource(resolved);
-              }
-            },
-            actionLabel: `Install dependency ${dep}`
-          } : {};
-          results.push({
-            check: `${folder} \u2192 ${dep}`,
-            status: "warning",
-            message: `Dependency "${dep}" is not installed`,
-            ...healAction
-          });
-        }
-      }
-    }
-  }
   if (results.length === 0) {
     const count = installedFolders.length;
     results.push({
@@ -4071,33 +4132,6 @@ Describe the shard context here.
       }
     }
   }
-  if (manifest?.depends) {
-    const installedFolders = await listInstalledShards(flintPath);
-    const installedKebabSet = new Set(installedFolders.map((f) => toKebabCase(f)));
-    for (const dep of manifest.depends) {
-      const depInstalled = isDepInstalled(dep, installedKebabSet, installedFolders, declarations);
-      if (!depInstalled) {
-        const healAction = isOwnerRepo(dep) ? {
-          action: async () => {
-            const source = parseShardSource(dep);
-            const resolved = await resolveShardSource(source, flintPath);
-            try {
-              await installShardFromSource(flintPath, resolved.path, resolved.manifest, { source: dep });
-            } finally {
-              await cleanupResolvedSource(resolved);
-            }
-          },
-          actionLabel: `Install dependency ${dep}`
-        } : {};
-        results.push({
-          check: `dependency: ${dep}`,
-          status: "warning",
-          message: `Not installed`,
-          ...healAction
-        });
-      }
-    }
-  }
   const checkFilePrefix = async (dir, prefix) => {
     try {
       const entries = await readdir42(join10(shardPath, dir), { withFileTypes: true });
@@ -4128,6 +4162,20 @@ Describe the shard context here.
   }
   return results;
 }
+async function healAllShards(flintPath) {
+  const allResults = {};
+  const installedFolders = await listInstalledShards(flintPath);
+  await Promise.all(installedFolders.map(async (folder) => {
+    const results = await healShard(flintPath, folder);
+    for (const result of results) {
+      if (result.action) {
+        await result.action();
+      }
+    }
+    allResults[folder] = results;
+  }));
+  return allResults;
+}
 async function getShardInfo(flintPath, identifier) {
   const declarations = await getShardDeclarations(flintPath);
   const installed = await getInstalledShardsWithVersions(flintPath);
@@ -4145,10 +4193,9 @@ async function getShardInfo(flintPath, identifier) {
       version: match.version,
       description: manifest?.description || "",
       source: decl?.source || "unknown",
-      dev: decl ? resolveShardMode(decl) === "dev" || !!decl.dev : false,
+      dev: decl ? resolveShardMode(decl) === "dev" : false,
       mode: decl ? resolveShardMode(decl) || "normal" : "normal",
       folderName: match.folderName,
-      depends: manifest?.depends || [],
       skillCount: await countFiles(join10(shardPath, "skills")),
       templateCount: await countFiles(join10(shardPath, "templates")),
       workflowCount: await countFiles(join10(shardPath, "workflows")),
@@ -4229,7 +4276,7 @@ async function findScript(scriptsDir, scriptName) {
 }
 async function isExecutable(filePath) {
   try {
-    await access4(filePath, constants.X_OK);
+    await access3(filePath, constants.X_OK);
     return true;
   } catch {
     return false;
@@ -4302,12 +4349,7 @@ async function runShardScript(flintPath, shardIdentifier, scriptName, args = [])
     });
   });
 }
-async function listBuiltinMods() {
-  return [];
-}
-async function getBuiltinMod(shorthand) {
-  return null;
-}
+var execAsync4 = promisify42(exec4);
 function isOwnerRepo2(s) {
   return /^[a-zA-Z0-9_.-]+\/[a-zA-Z0-9_.-]+$/.test(s);
 }
@@ -4365,8 +4407,7 @@ async function resolveModSource(source, flintPath) {
 async function cloneAndResolve2(url, source) {
   const tempDir = await mkdtemp2(join12(tmpdir2(), "flint-mod-"));
   try {
-    execSync3(`git clone --depth 1 ${url} "${tempDir}"`, {
-      stdio: "pipe",
+    await execAsync4(`git clone --depth 1 ${url} "${tempDir}"`, {
       timeout: 6e4
       // 60 second timeout
     });
@@ -4462,7 +4503,7 @@ function renderTemplate(template, variables) {
 }
 function runCommand(flintPath, command) {
   try {
-    execSync4(command, {
+    execSync(command, {
       cwd: flintPath,
       stdio: "pipe",
       timeout: 3e4
@@ -4509,7 +4550,7 @@ async function processInstallEntries(flintPath, mod, variables, options) {
       continue;
     }
     if (await exists(destFilePath)) {
-      const mode = entry.mode ?? (entry.force ? "force" : "once");
+      const mode = entry.mode ?? "once";
       if (!options?.force && mode === "once") continue;
       if (mode === "force" || options?.force) {
         try {
@@ -4567,16 +4608,7 @@ async function installMod(flintPath, shorthand, options = {}) {
       }
     }
   }
-  const mod = await getBuiltinMod(shorthand);
-  if (!mod) {
-    const available = await listBuiltinMods();
-    const shorthands = available.map((m) => m.shorthand).join(", ");
-    throw new Error(`Unknown mod: ${shorthand}. Available: ${shorthands || "none"}`);
-  }
-  return installModFromSource(flintPath, mod.path, mod, {
-    source: options.source || "builtin",
-    force: options.force
-  });
+  throw new Error(`Unknown mod: ${shorthand}. Provide a source (owner/repo or path:./local).`);
 }
 async function installModFromSource(flintPath, sourcePath, mod, options = {}) {
   const destPath = join13(flintPath, "Mods", mod.name);
@@ -4661,11 +4693,7 @@ async function uninstallMod(flintPath, shorthand) {
   return { name: modName, removed: true };
 }
 async function listAvailableMods() {
-  return listBuiltinMods();
-}
-async function isModInstalled(flintPath, shorthand) {
-  const folder = await findInstalledModFolder(flintPath, shorthand);
-  return folder !== null;
+  return [];
 }
 async function findInstalledModFolder(flintPath, identifier) {
   const modsDir = join13(flintPath, "Mods");
@@ -4751,27 +4779,13 @@ async function updateMods(flintPath, options = {}) {
       }
     }
     if (!source || source === "builtin") {
-      const mod = await getBuiltinMod(info2.shorthand);
-      if (mod) {
-        try {
-          await installMod(flintPath, mod.shorthand, { force: true, source: source || "builtin" });
-          results.push({
-            name: info2.name,
-            path: join13(flintPath, "Mods", info2.folderName),
-            status: "updated",
-            localVersion: info2.version,
-            remoteVersion: mod.version
-          });
-        } catch {
-          results.push({
-            name: info2.name,
-            path: join13(flintPath, "Mods", info2.folderName),
-            status: "failed",
-            localVersion: info2.version,
-            reason: "failed to reinstall from registry"
-          });
-        }
-      }
+      results.push({
+        name: info2.name,
+        path: join13(flintPath, "Mods", info2.folderName),
+        status: "failed",
+        localVersion: info2.version,
+        reason: "no source configured (builtin mods no longer supported)"
+      });
       continue;
     }
     const parsed = parseModSource(source);
@@ -4890,22 +4904,6 @@ async function getModInfo(flintPath, identifier) {
     }
   } catch {
   }
-  const mod = await getBuiltinMod(identifier);
-  if (mod) {
-    return {
-      name: mod.name,
-      shorthand: mod.shorthand,
-      version: mod.version,
-      description: mod.description,
-      folderName: mod.name,
-      source: "builtin",
-      dev: false,
-      repos: mod.repos || [],
-      folders: mod.folders || [],
-      installEntries: mod.install?.length || 0,
-      commands: mod.commands || {}
-    };
-  }
   return null;
 }
 async function scaffoldNewMod(flintPath, name, shorthand, description) {
@@ -5019,14 +5017,14 @@ async function pullMod(flintPath, identifier, options) {
           const repoDir = join13(reposDir, repo.name);
           if (await exists(repoDir)) {
             try {
-              execSync4("git pull", { cwd: repoDir, stdio: "pipe", timeout: 3e4 });
+              execSync("git pull", { cwd: repoDir, stdio: "pipe", timeout: 3e4 });
               result.reposPulled++;
             } catch {
             }
           } else {
             try {
               const branch = repo.branch ? `-b ${repo.branch}` : "";
-              execSync4(`git clone ${branch} "${repo.url}" "${repoDir}"`, { stdio: "pipe", timeout: 6e4 });
+              execSync(`git clone ${branch} "${repo.url}" "${repoDir}"`, { stdio: "pipe", timeout: 6e4 });
               result.reposCloned++;
             } catch {
             }
@@ -5337,7 +5335,7 @@ async function runModScript(flintPath, identifier, scriptName, args = []) {
       cmd = `"${script.path}" ${args.join(" ")}`;
   }
   try {
-    const result = execSync4(cmd, {
+    const result = execSync(cmd, {
       cwd: flintPath,
       timeout: 6e4,
       encoding: "utf-8"
@@ -5526,7 +5524,7 @@ async function getConnectionStatus(flintPath) {
       status.path = fulfillment.path;
       status.fulfilledAt = fulfillment.fulfilled;
       try {
-        await access5(fulfillment.path);
+        await access4(fulfillment.path);
         const isFlint2 = await isInsideFlint(fulfillment.path);
         status.valid = isFlint2;
       } catch {
@@ -5613,12 +5611,16 @@ async function buildGitignoreEntries(flintPath) {
   const sections = [];
   sections.push({
     label: "Flint internals",
-    entries: [".flint/", ".obsidian/", ".mesh/"]
+    entries: [".flint/", ".obsidian/", ".mesh/", ".orbh/"]
+  });
+  sections.push({
+    label: "Subflints",
+    entries: ["Subflints/"]
   });
-  const shardEntries = buildShardEntries(config);
+  const shardEntries = await buildShardEntries(flintPath);
   if (shardEntries.length > 0) {
     sections.push({
-      label: "Shards (dev)",
+      label: "Shards (git-managed)",
       entries: shardEntries
     });
   }
@@ -5655,18 +5657,20 @@ function buildWorkspaceEntries(config) {
   }
   return entries;
 }
-function buildShardEntries(config) {
-  if (!config?.shards) return [];
+async function buildShardEntries(flintPath) {
+  const shardsDir = join15(flintPath, "Shards");
+  if (!await exists(shardsDir)) return [];
   const entries = [];
-  for (const [, decl] of Object.entries(config.shards)) {
-    if (typeof decl !== "object" || !("source" in decl)) continue;
-    const mode = resolveShardMode(decl);
-    if (mode === "dev" || mode === "custom") {
-      const match = decl.source.match(/^path:\.\/Shards\/(.+)$/);
-      if (match) {
-        entries.push(`Shards/${match[1]}/`);
+  try {
+    const folders = await readdir7(shardsDir, { withFileTypes: true });
+    for (const folder of folders) {
+      if (!folder.isDirectory() || folder.name.startsWith("(System)")) continue;
+      const gitDir = join15(shardsDir, folder.name, ".git");
+      if (await exists(gitDir)) {
+        entries.push(`Shards/${folder.name}/`);
       }
     }
+  } catch {
   }
   return entries.sort();
 }
@@ -5728,15 +5732,28 @@ ${MANAGED_SECTION_END}`;
 function escapeRegex(str) {
   return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-var execAsync2 = promisify22(exec2);
+var execAsync5 = promisify52(exec5);
 async function isGitInitialized(flintPath) {
   try {
-    await execAsync2("git rev-parse --git-dir", { cwd: flintPath });
+    await execAsync5("git rev-parse --git-dir", { cwd: flintPath });
     return true;
   } catch {
     return false;
   }
 }
+async function initGit(flintPath) {
+  try {
+    await execAsync5("git init", { cwd: flintPath });
+    await createGitignore(flintPath);
+    return { success: true, output: "Git initialized with .gitignore" };
+  } catch (err) {
+    return {
+      success: false,
+      output: "",
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+}
 async function getGitStatus(flintPath) {
   const initialized = await isGitInitialized(flintPath);
   if (!initialized) {
@@ -5749,10 +5766,10 @@ async function getGitStatus(flintPath) {
     };
   }
   try {
-    const { stdout: branchOut } = await execAsync2("git branch --show-current", {
+    const { stdout: branchOut } = await execAsync5("git branch --show-current", {
       cwd: flintPath
     });
-    const { stdout: statusOut } = await execAsync2("git status --porcelain", {
+    const { stdout: statusOut } = await execAsync5("git status --porcelain", {
       cwd: flintPath
     });
     const lines = statusOut.trim().split("\n").filter(Boolean);
@@ -5794,7 +5811,7 @@ async function runGit(flintPath, args) {
     const quotedArgs = args.map(
       (arg) => arg.includes(" ") ? `"${arg}"` : arg
     );
-    const { stdout, stderr } = await execAsync2(`git ${quotedArgs.join(" ")}`, {
+    const { stdout, stderr } = await execAsync5(`git ${quotedArgs.join(" ")}`, {
       cwd: flintPath
     });
     return { success: true, output: stdout || stderr };
@@ -5843,7 +5860,7 @@ async function loadPresetFromDir(presetDir) {
 async function discoverPresetsFromDir(presetsDir) {
   const presets = /* @__PURE__ */ new Map();
   try {
-    const entries = await readdir7(presetsDir, { withFileTypes: true });
+    const entries = await readdir8(presetsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
       const presetDir = join16(presetsDir, entry.name);
@@ -5908,7 +5925,7 @@ async function discoverSubflints(flintPath) {
   const discovered = [];
   let entries;
   try {
-    entries = await readdir8(subflintsDir, { withFileTypes: true });
+    entries = await readdir9(subflintsDir, { withFileTypes: true });
   } catch (err) {
     if (err.code === "ENOENT") {
       return discovered;
@@ -5952,7 +5969,7 @@ async function createSubflint(flintPath, options) {
   }
   const subflintPath = getSubflintPath(flintPath, name);
   try {
-    await access6(subflintPath);
+    await access5(subflintPath);
     throw new Error(`Subflint "${name}" already exists`);
   } catch (err) {
     if (err.code !== "ENOENT") {
@@ -5995,14 +6012,14 @@ async function promoteSubflint(flintPath, options) {
   }
   const sourcePath = subflint.path;
   try {
-    await access6(sourcePath);
+    await access5(sourcePath);
   } catch {
     throw new Error(`Subflint path not found: ${sourcePath}`);
   }
   const targetPath = join17(destination, `(Flint) ${name}`);
   await mkdir10(destination, { recursive: true });
   try {
-    await access6(targetPath);
+    await access5(targetPath);
     throw new Error(`Target already exists: ${targetPath}`);
   } catch (err) {
     if (err.code !== "ENOENT") {
@@ -6052,7 +6069,7 @@ async function syncSubflintName(flintPath, currentName) {
   }
   const targetPath = getSubflintPath(flintPath, configName);
   try {
-    await access6(targetPath);
+    await access5(targetPath);
     throw new Error(
       `Cannot rename: subflint "${configName}" already exists at ${targetPath}`
     );
@@ -6081,7 +6098,7 @@ function getSubflintParentPath(flintPath) {
   }
   return dirname6(subflintsDir);
 }
-async function syncFlint(flintPath) {
+async function syncFlint(flintPath, progress) {
   const result = {
     bootstrap: { created: false, directories: [] },
     migrations: { applied: [], skipped: [], failed: [] },
@@ -6163,28 +6180,76 @@ async function syncFlint(flintPath) {
   const shardsToInstall = requiredShardNames.filter((name) => !installedShardNames.has(name));
   const requiredShardSet = new Set(requiredShardNames);
   const shardsToUninstall = installedShards.filter((s) => !requiredShardSet.has(s.name)).map((s) => s.name);
-  for (const kebabName of shardsToInstall) {
-    const declaration = shardDeclarations[kebabName];
-    if (!declaration) continue;
-    if (declaration.dev) continue;
-    try {
-      const source = parseShardSource(declaration.source);
-      const resolved = await resolveShardSource(source, flintPath);
-      try {
-        await installShardFromSource(flintPath, resolved.path, resolved.manifest, {
-          force: true,
-          source: declaration.source
-        });
-      } finally {
-        await cleanupResolvedSource(resolved);
-      }
-      result.shards.installed.push(kebabName);
-    } catch (err) {
-      result.errors.push({
-        name: `shard:${kebabName}`,
-        error: err instanceof Error ? err.message : String(err)
+  {
+    const { exec: execCb } = await import("child_process");
+    const { promisify: promisify62 } = await import("util");
+    const execAsync62 = promisify62(execCb);
+    const shardTasks = [];
+    for (const kebabName of shardsToInstall) {
+      const declaration = shardDeclarations[kebabName];
+      if (!declaration) continue;
+      const mode = declaration.mode;
+      if (mode === "dev") {
+        const source = declaration.source;
+        if (source.startsWith("path:")) {
+          result.errors.push({
+            name: `shard:${kebabName}`,
+            error: `Dev shard has no remote source (${source}) \u2014 cannot sync. Add a git remote first.`
+          });
+          continue;
+        }
+        shardTasks.push({
+          name: kebabName,
+          run: async () => {
+            const folderName = `(Dev) ${kebabName.split("-").map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join(" ")}`;
+            const devPath = join18(flintPath, "Shards", folderName);
+            const cloneUrl = `https://github.com/${source}.git`;
+            await execAsync62(`git clone "${cloneUrl}" "${devPath}"`, { timeout: 6e4 });
+          }
+        });
+        continue;
+      }
+      if (mode === "custom") {
+        result.errors.push({
+          name: `shard:${kebabName}`,
+          error: `Custom shard folder missing \u2014 custom shards should be committed to the repository.`
+        });
+        continue;
+      }
+      shardTasks.push({
+        name: kebabName,
+        run: async () => {
+          const source = parseShardSource(declaration.source);
+          const resolved = await resolveShardSource(source, flintPath);
+          try {
+            await installShardFromSource(flintPath, resolved.path, resolved.manifest, {
+              force: true,
+              source: declaration.source
+            });
+          } finally {
+            await cleanupResolvedSource(resolved);
+          }
+        }
       });
     }
+    progress?.onShardPhase?.(shardTasks.length);
+    if (shardTasks.length > 0) {
+      const shardResults = await runConcurrent(shardTasks, {
+        onStart: progress?.onShardStart,
+        onComplete: (name) => progress?.onShardDone?.(name, true),
+        onError: (name) => progress?.onShardDone?.(name, false)
+      });
+      for (const r of shardResults) {
+        if (r.status === "ok") {
+          result.shards.installed.push(r.name);
+        } else {
+          result.errors.push({
+            name: `shard:${r.name}`,
+            error: r.error?.message || "Unknown error"
+          });
+        }
+      }
+    }
   }
   for (const kebabName of shardsToUninstall) {
     result.shards.orphaned.push(kebabName);
@@ -6209,16 +6274,29 @@ async function syncFlint(flintPath) {
   const installedModNames = new Set(installedMods.map((m) => toKebabCase(m.name)));
   const modsToInstall = [...declaredModNames].filter((name) => !installedModNames.has(name));
   const modsToUninstall = installedMods.filter((m) => !declaredModNames.has(toKebabCase(m.name))).map((m) => m.shorthand);
-  for (const kebabName of modsToInstall) {
-    const declaration = modDeclarations[kebabName];
-    try {
-      await installMod(flintPath, kebabName, { force: true, source: declaration?.source });
-      result.mods.installed.push(kebabName);
-    } catch (err) {
-      result.errors.push({
-        name: `mod:${kebabName}`,
-        error: err instanceof Error ? err.message : String(err)
-      });
+  progress?.onModPhase?.(modsToInstall.length);
+  if (modsToInstall.length > 0) {
+    const modTasks = modsToInstall.map((kebabName) => ({
+      name: kebabName,
+      run: async () => {
+        const declaration = modDeclarations[kebabName];
+        await installMod(flintPath, kebabName, { force: true, source: declaration?.source });
+      }
+    }));
+    const modResults = await runConcurrent(modTasks, {
+      onStart: progress?.onModStart,
+      onComplete: (name) => progress?.onModDone?.(name, true),
+      onError: (name) => progress?.onModDone?.(name, false)
+    });
+    for (const r of modResults) {
+      if (r.status === "ok") {
+        result.mods.installed.push(r.name);
+      } else {
+        result.errors.push({
+          name: `mod:${r.name}`,
+          error: r.error?.message || "Unknown error"
+        });
+      }
     }
   }
   for (const shorthand of modsToUninstall) {
@@ -6239,18 +6317,18 @@ async function syncFlint(flintPath) {
   }
   result.modCommands = await runModSyncCommands(flintPath);
   const requiredImports = config.imports?.flints || config.imports?.required || [];
-  const { getFlintRegistry: getFlintRegistry2 } = await import("./registry-5QFQ3XPR-G7IB3KWS.js");
-  const { readdir: readdir92, readFile: fsReadFile2, writeFile: fsWriteFile2, rm: rm82, stat: fsStat } = await import("fs/promises");
+  const { getFlintRegistry: getFlintRegistry2 } = await import("./registry-5PUMDGQP-YVSEVBB4.js");
+  const { readdir: readdir102, readFile: fsReadFile2, writeFile: fsWriteFile2, rm: rm82, stat: fsStat } = await import("fs/promises");
   const requiredImportSet = new Set(requiredImports);
   const importsDir = join18(flintPath, "Imports");
   try {
-    const flintFolders = await readdir92(importsDir, { withFileTypes: true });
+    const flintFolders = await readdir102(importsDir, { withFileTypes: true });
     for (const flintFolder of flintFolders) {
       if (!flintFolder.isDirectory()) continue;
       const flintFolderName = flintFolder.name;
       const flintName = flintFolderName.replace(/^\(Flint\)\s*/, "");
       const flintImportPath = join18(importsDir, flintFolderName);
-      const exportFolders = await readdir92(flintImportPath, { withFileTypes: true });
+      const exportFolders = await readdir102(flintImportPath, { withFileTypes: true });
       for (const exportFolder of exportFolders) {
         if (!exportFolder.isDirectory()) continue;
         const exportFolderName = exportFolder.name;
@@ -6270,7 +6348,7 @@ async function syncFlint(flintPath) {
           }
         }
       }
-      const remainingExports = await readdir92(flintImportPath);
+      const remainingExports = await readdir102(flintImportPath);
       if (remainingExports.length === 0) {
         try {
           await rm82(flintImportPath, { recursive: true });
@@ -6282,7 +6360,7 @@ async function syncFlint(flintPath) {
   }
   if (requiredImports.length > 0) {
     const registry = await getFlintRegistry2();
-    const { buildExportByName: buildExportByName2, scanExports: scanExports2 } = await import("./exports-CA5QHVI7-6IDFKMCF.js");
+    const { buildExportByName: buildExportByName2, scanExports: scanExports2 } = await import("./exports-KXKBTYJ2-A3QWNDEB.js");
     for (const ref of requiredImports) {
       const parts = ref.split("/");
       if (parts.length !== 2) {
@@ -6305,7 +6383,7 @@ async function syncFlint(flintPath) {
       const manifests = await scanExports2(sourceFlint.path);
       const hasExportManifest = manifests.some((m) => m.name === exportName);
       if (!hasExportManifest) {
-        result.imports.push({ ref, status: "not_found", error: "Export not defined" });
+        result.imports.push({ ref, status: "export_not_found", error: `export '${exportName}' not found in '${flintName}'` });
         continue;
       }
       try {
@@ -6335,7 +6413,7 @@ async function syncFlint(flintPath) {
         } catch {
         }
         await mkdir11(destPath, { recursive: true });
-        const entries = await readdir92(sourcePath, { withFileTypes: true });
+        const entries = await readdir102(sourcePath, { withFileTypes: true });
         let fileCount = 0;
         for (const entry of entries) {
           if (entry.isFile() && entry.name !== "_manifest.json") {
@@ -6439,8 +6517,22 @@ async function syncFlint(flintPath) {
   }
   const connectionsMigration = await migrateConnections(currentFlintPath);
   result.connectionsMigrated = connectionsMigration.migrated;
-  await writeFlintToml(currentFlintPath, config);
-  await updateGitignore(currentFlintPath);
+  try {
+    await writeFlintToml(currentFlintPath, config);
+  } catch (err) {
+    result.errors.push({
+      name: "flint.toml",
+      error: `Failed to write flint.toml: ${err instanceof Error ? err.message : String(err)}`
+    });
+  }
+  try {
+    await updateGitignore(currentFlintPath);
+  } catch (err) {
+    result.errors.push({
+      name: "gitignore",
+      error: `Failed to update .gitignore: ${err instanceof Error ? err.message : String(err)}`
+    });
+  }
   try {
     await stampSynced(currentFlintPath);
   } catch {
@@ -6448,9 +6540,64 @@ async function syncFlint(flintPath) {
   return result;
 }
 
+// src/progress.ts
+import pc5 from "picocolors";
+function createProgressDisplay(label, total) {
+  if (total === 0) {
+    return { onStart() {
+    }, onComplete() {
+    }, onError() {
+    }, finish() {
+    } };
+  }
+  const isTTY = process.stdout.isTTY;
+  let completed = 0;
+  let failures = 0;
+  let finished = false;
+  let linesBelow = 0;
+  console.log(pc5.bold(label));
+  return {
+    onStart(_name) {
+    },
+    onComplete(name) {
+      completed++;
+      linesBelow++;
+      console.log(`  ${pc5.green("\u2713")} ${name}`);
+    },
+    onError(name) {
+      completed++;
+      failures++;
+      linesBelow++;
+      console.log(`  ${pc5.red("\u2717")} ${name}`);
+    },
+    finish() {
+      if (finished) return;
+      finished = true;
+      const successes = completed - failures;
+      let summary = `${pc5.bold(label)} `;
+      if (failures === 0) {
+        summary += pc5.green(`\u2713 ${successes} done`);
+      } else {
+        summary += `${pc5.green(`\u2713 ${successes} done`)} ${pc5.red(`\u2717 ${failures} failed`)}`;
+      }
+      if (isTTY) {
+        const up = linesBelow + 1;
+        process.stdout.write(
+          `\x1B[${up}A\x1B[2K\r` + // clear line
+          summary + // write summary
+          `\x1B[${up}B\r`
+          // back down to original position
+        );
+      } else {
+        console.log(summary);
+      }
+    }
+  };
+}
+
 // src/utils.ts
 import { homedir as homedir4 } from "os";
-import { access as access7 } from "fs/promises";
+import { access as access6 } from "fs/promises";
 import { createInterface } from "readline";
 function abbreviatePath(path3) {
   const home = homedir4();
@@ -6467,7 +6614,7 @@ function expandPath(path3) {
 }
 async function checkPathExists(path3) {
   try {
-    await access7(path3);
+    await access6(path3);
     return true;
   } catch {
     return false;
@@ -6487,120 +6634,37 @@ async function confirm(message) {
 }
 
 // src/commands/init.ts
+var execAsync6 = promisify7(exec6);
 function openObsidianVaultChooser() {
   const os2 = platform2();
   const uri = "obsidian://choose-vault";
   try {
     if (os2 === "darwin") {
-      execSync5(`open "${uri}"`, { stdio: "pipe" });
+      execSync2(`open "${uri}"`, { stdio: "pipe" });
     } else if (os2 === "win32") {
-      execSync5(`start "" "${uri}"`, { stdio: "pipe" });
+      execSync2(`start "" "${uri}"`, { stdio: "pipe" });
     } else {
-      execSync5(`xdg-open "${uri}"`, { stdio: "pipe" });
+      execSync2(`xdg-open "${uri}"`, { stdio: "pipe" });
     }
   } catch {
   }
 }
-var initCommand = new Command3("init").description("Create a new Flint workspace").argument("[name]", "Name of the flint").option("-p, --path <dir>", "Parent directory (default: current directory)").option("--preset <name>", 'Use a preset (e.g., "default")').action(async (name, options) => {
-  if (!name) {
-    console.error(pc5.red("Error: Flint name is required"));
-    console.log("\nUsage: flint init <name> [options]");
-    process.exit(1);
-  }
-  const presetName = options.preset || "blank";
-  const preset = await getPreset(presetName);
-  if (!preset) {
-    const available = (await listPresets()).map((p) => p.name).join(", ");
-    console.error(pc5.red(`Error: Unknown preset "${presetName}"`));
-    console.log(`Available presets: ${available}`);
-    process.exit(1);
+function reportSyncResult(result) {
+  if (result.obsidian.cloned) {
+    console.log();
+    success("Cloned .obsidian/");
   }
-  const shards = preset.shards;
-  const mods = preset.mods;
-  if (options.preset) {
-    console.log(`
-Using preset: ${pc5.bold(preset.name)}`);
+  if (!result.obsidian.cloned && result.shards.installed.length === 0 && result.mods.installed.length === 0 && result.errors.length === 0) {
+    console.log(pc6.dim("  Already in sync"));
   }
-  console.log(`
-Creating flint: ${pc5.bold(name)}`);
-  try {
-    const entry = await createFlint({
-      name,
-      parentDir: options.path,
-      shards,
-      mods
-    });
-    success(`Created (Flint) ${name}/`);
-    for (const dir of STANDARD_DIRECTORIES) {
-      success(`Created ${dir}/`);
-    }
-    success("Created .flint/");
-    success("Created flint.toml");
-    success("Created flint.lock");
-    success("Registered in ~/.flint/");
-    if (preset && preset.templates.length > 0) {
-      await applyPresetTemplates(entry.path, preset, name);
-      success(`Applied ${preset.templates.length} template(s) from preset`);
-    }
-    console.log(`
-Flint created at: ${pc5.cyan(abbreviatePath(entry.path))}`);
-    console.log(pc5.bold("\nSyncing configured features...\n"));
-    const result = await syncFlint(entry.path);
-    if (result.obsidian.cloned) {
-      success("Cloned .obsidian/");
-    }
-    if (result.shards.installed.length > 0) {
-      console.log(pc5.green("\nShards installed:"));
-      for (const s of result.shards.installed) {
-        console.log(`  ${pc5.green("+")} ${s}`);
-      }
-    }
-    if (result.mods.installed.length > 0) {
-      console.log(pc5.green("\nMods installed:"));
-      for (const s of result.mods.installed) {
-        console.log(`  ${pc5.green("+")} ${s}`);
-      }
-      const cmdResults = await runModSyncCommands(entry.path);
-      const failedCmds = cmdResults.filter((r) => !r.success);
-      if (failedCmds.length > 0) {
-        console.log(pc5.yellow("\nMod command warnings:"));
-        for (const c of failedCmds) {
-          console.log(`  ${pc5.yellow("!")} ${c.command}: ${c.error}`);
-        }
-      }
-    }
-    if (!result.obsidian.cloned && result.shards.installed.length === 0 && result.mods.installed.length === 0 && result.errors.length === 0) {
-      console.log(pc5.dim("Flint is already in sync."));
-    }
-    if (result.errors.length > 0) {
-      console.log(pc5.yellow("\nWarnings:"));
-      for (const e of result.errors) {
-        console.log(`  ${pc5.yellow("!")} ${e.name}: ${e.error}`);
-      }
-    }
-    if (result.obsidian.cloned) {
-      console.log(pc5.dim("Opening Obsidian vault chooser..."));
-      openObsidianVaultChooser();
-    }
+  if (result.errors.length > 0) {
     console.log();
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    error(message);
-    process.exit(1);
+    for (const e of result.errors) {
+      console.log(`  ${pc6.yellow("!")} ${e.name}: ${e.error}`);
+    }
   }
-});
-
-// src/commands/clone.ts
-import { Command as Command4 } from "commander";
-import pc6 from "picocolors";
-import { resolve as resolve8, join as join19 } from "path";
-import { existsSync as existsSync2 } from "fs";
-import { mkdtemp as mkdtemp3, rm as rm8, rename as rename4 } from "fs/promises";
-import { tmpdir as tmpdir3 } from "os";
-import { exec as exec3 } from "child_process";
-import { promisify as promisify7 } from "util";
-var execAsync3 = promisify7(exec3);
-var cloneCommand = new Command4("clone").description("Clone a flint from a git repository").argument("<url>", "Git repository URL").option("-p, --path <dir>", "Parent directory (default: current directory)").action(async (url, options) => {
+}
+async function handleFromGit(url, options) {
   const parentDir = resolve8(options.path || process.cwd());
   let tempDir = null;
   try {
@@ -6609,7 +6673,7 @@ Cloning ${pc6.cyan(url)}...
 `);
     tempDir = await mkdtemp3(join19(tmpdir3(), "flint-clone-"));
     try {
-      await execAsync3(`git clone "${url}" "${tempDir}"`, { timeout: 12e4 });
+      await execAsync6(`git clone "${url}" "${tempDir}"`, { timeout: 12e4 });
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
       throw new Error(`Git clone failed: ${message}`);
@@ -6625,6 +6689,13 @@ Cloning ${pc6.cyan(url)}...
     }
     const name = toml.flint.name;
     success(`Found flint: ${pc6.bold(name)}`);
+    const existing = await isFlintNameTaken(name);
+    if (existing) {
+      throw new Error(
+        `A flint named "${name}" already exists at: ${existing.path}
+Each flint must have a unique name for commands like 'flint open' and 'flint import' to work.`
+      );
+    }
     const prefix = getTypePrefix();
     const folderName = `${prefix} ${name}`;
     const finalPath = join19(parentDir, folderName);
@@ -6639,22 +6710,150 @@ Cloning ${pc6.cyan(url)}...
     console.log(`
 Flint cloned to: ${pc6.cyan(abbreviatePath(finalPath))}`);
     console.log(pc6.bold("\nSyncing...\n"));
-    const result = await syncFlint(finalPath);
-    if (result.obsidian.cloned) {
-      success("Cloned .obsidian/");
+    let shardProgress;
+    let modProgress;
+    const progress = {
+      onShardPhase(total) {
+        if (total > 0) shardProgress = createProgressDisplay("Installing shards", total);
+      },
+      onShardStart(name2) {
+        shardProgress?.onStart(name2);
+      },
+      onShardDone(name2, ok) {
+        ok ? shardProgress?.onComplete(name2) : shardProgress?.onError(name2);
+      },
+      onModPhase(total) {
+        shardProgress?.finish();
+        if (total > 0) modProgress = createProgressDisplay("Installing mods", total);
+      },
+      onModStart(name2) {
+        modProgress?.onStart(name2);
+      },
+      onModDone(name2, ok) {
+        ok ? modProgress?.onComplete(name2) : modProgress?.onError(name2);
+      }
+    };
+    const result = await syncFlint(finalPath, progress);
+    shardProgress?.finish();
+    modProgress?.finish();
+    reportSyncResult(result);
+    console.log(pc6.bold("\nHealing shards...\n"));
+    const healResults = await healAllShards(finalPath);
+    let totalHealed = 0;
+    for (const [folder, results] of Object.entries(healResults)) {
+      const actions = results.filter((r) => r.action);
+      if (actions.length > 0) {
+        totalHealed += actions.length;
+        for (const r of actions) {
+          console.log(`  ${pc6.green("+")} ${folder}: ${r.actionLabel}`);
+        }
+      }
+    }
+    if (totalHealed > 0) {
+      success(`Healed ${totalHealed} issue(s) across shards`);
+    } else {
+      console.log(pc6.dim("All shards healthy."));
     }
-    if (result.shards.installed.length > 0) {
-      console.log(pc6.green("\nShards installed:"));
-      for (const s of result.shards.installed) {
-        console.log(`  ${pc6.green("+")} ${s}`);
+    console.log(pc6.bold(`
+Ready to use!
+`));
+    console.log(`  cd ${abbreviatePath(finalPath)}`);
+    console.log(`  flint open          ${pc6.dim("Open in Obsidian")}`);
+    console.log(`  flint sync          ${pc6.dim("Update anytime")}`);
+    console.log();
+  } catch (err) {
+    if (tempDir) {
+      try {
+        await rm8(tempDir, { recursive: true, force: true });
+      } catch {
       }
     }
-    if (result.mods.installed.length > 0) {
-      console.log(pc6.green("\nMods installed:"));
-      for (const s of result.mods.installed) {
-        console.log(`  ${pc6.green("+")} ${s}`);
+    const message = err instanceof Error ? err.message : String(err);
+    error(message);
+    process.exit(1);
+  }
+}
+var initCommand = new Command3("init").description("Create a new Flint workspace").argument("[name]", "Name of the flint").option("-p, --path <dir>", "Parent directory (default: current directory)").option("--preset <name>", 'Use a preset (e.g., "default")').option("--from-git <url>", "Clone a flint from a git repository").action(async (name, options) => {
+  if (options.fromGit) {
+    await handleFromGit(options.fromGit, options);
+    return;
+  }
+  if (!name) {
+    console.error(pc6.red("Error: Flint name is required"));
+    console.log("\nUsage: flint init <name> [options]");
+    console.log("       flint init --from-git <url> [options]");
+    process.exit(1);
+  }
+  const presetName = options.preset || "blank";
+  const preset = await getPreset(presetName);
+  if (!preset) {
+    const available = (await listPresets()).map((p) => p.name).join(", ");
+    console.error(pc6.red(`Error: Unknown preset "${presetName}"`));
+    console.log(`Available presets: ${available}`);
+    process.exit(1);
+  }
+  const shards = preset.shards;
+  const mods = preset.mods;
+  if (options.preset) {
+    console.log(`
+Using preset: ${pc6.bold(preset.name)}`);
+  }
+  console.log(`
+Creating flint: ${pc6.bold(name)}
+`);
+  try {
+    const entry = await createFlint({
+      name,
+      parentDir: options.path,
+      shards,
+      mods
+    });
+    const dirs = STANDARD_DIRECTORIES.join(", ");
+    success(`Created (Flint) ${name}/`);
+    console.log(pc6.dim(`  ${dirs}, .flint/, flint.toml, flint.lock
+`));
+    success("Registered in ~/.nuucognition/flint/");
+    if (preset && preset.templates.length > 0) {
+      await applyPresetTemplates(entry.path, preset, name);
+      success(`Applied ${preset.templates.length} template(s) from preset`);
+    }
+    console.log(`
+  ${pc6.cyan(abbreviatePath(entry.path))}
+`);
+    if (shards.length > 0 || mods.length > 0) {
+      console.log(pc6.bold("Syncing...\n"));
+    }
+    let initShardProgress;
+    let initModProgress;
+    const initProgress = {
+      onShardPhase(total) {
+        if (total > 0) initShardProgress = createProgressDisplay("Installing shards", total);
+      },
+      onShardStart(name2) {
+        initShardProgress?.onStart(name2);
+      },
+      onShardDone(name2, ok) {
+        ok ? initShardProgress?.onComplete(name2) : initShardProgress?.onError(name2);
+      },
+      onModPhase(total) {
+        initShardProgress?.finish();
+        if (total > 0) {
+          console.log();
+          initModProgress = createProgressDisplay("Installing mods", total);
+        }
+      },
+      onModStart(name2) {
+        initModProgress?.onStart(name2);
+      },
+      onModDone(name2, ok) {
+        ok ? initModProgress?.onComplete(name2) : initModProgress?.onError(name2);
       }
-      const cmdResults = await runModSyncCommands(finalPath);
+    };
+    const result = await syncFlint(entry.path, initProgress);
+    initShardProgress?.finish();
+    initModProgress?.finish();
+    if (result.mods.installed.length > 0) {
+      const cmdResults = await runModSyncCommands(entry.path);
       const failedCmds = cmdResults.filter((r) => !r.success);
       if (failedCmds.length > 0) {
         console.log(pc6.yellow("\nMod command warnings:"));
@@ -6663,23 +6862,13 @@ Flint cloned to: ${pc6.cyan(abbreviatePath(finalPath))}`);
         }
       }
     }
-    if (!result.obsidian.cloned && result.shards.installed.length === 0 && result.mods.installed.length === 0 && result.errors.length === 0) {
-      console.log(pc6.dim("Flint is already in sync."));
-    }
-    if (result.errors.length > 0) {
-      console.log(pc6.yellow("\nWarnings:"));
-      for (const e of result.errors) {
-        console.log(`  ${pc6.yellow("!")} ${e.name}: ${e.error}`);
-      }
+    reportSyncResult(result);
+    if (result.obsidian.cloned) {
+      console.log(pc6.dim("\nOpening Obsidian vault chooser..."));
+      openObsidianVaultChooser();
     }
     console.log();
   } catch (err) {
-    if (tempDir) {
-      try {
-        await rm8(tempDir, { recursive: true, force: true });
-      } catch {
-      }
-    }
     const message = err instanceof Error ? err.message : String(err);
     error(message);
     process.exit(1);
@@ -6687,7 +6876,7 @@ Flint cloned to: ${pc6.cyan(abbreviatePath(finalPath))}`);
 });
 
 // src/commands/list.ts
-import { Command as Command5 } from "commander";
+import { Command as Command4 } from "commander";
 import pc7 from "picocolors";
 function stripAnsi(str) {
   return str.replace(/\x1b\[[0-9;]*m/g, "");
@@ -6745,7 +6934,7 @@ function measureNameCol(flints) {
   }
   return max + 3;
 }
-var listCmd = new Command5("list").alias("ls").description("List all registered flints").option("--json", "Output as JSON").option("--full-path", "Show full paths (not abbreviated)").option("-s, --status", "Show valid/broken status for each entry").option("-g, --group", "Group flints by tag").option("-t, --tag <tag>", "Filter flints by tag").option("--search <query>", "Search flints by name or description").option("--tree", "Show parent/subflint hierarchy").option("--no-sub", "Hide subflints from output");
+var listCmd = new Command4("list").alias("ls").description("List all registered flints").option("--json", "Output as JSON").option("--full-path", "Show full paths (not abbreviated)").option("-s, --status", "Show valid/broken status for each entry").option("-g, --group", "Group flints by tag").option("-t, --tag <tag>", "Filter flints by tag").option("--search <query>", "Search flints by name or description").option("--tree", "Show parent/subflint hierarchy").option("--no-sub", "Hide subflints from output");
 var listCommand = listCmd.action(async (options) => {
   try {
     let flints = await getFlintRegistry();
@@ -6876,10 +7065,11 @@ var listCommand = listCmd.action(async (options) => {
 });
 
 // src/commands/shard.ts
-import { Command as Command6 } from "commander";
+import { Command as Command5 } from "commander";
 import { spawn as spawn2 } from "child_process";
 import { join as join20 } from "path";
 import { existsSync as existsSync3 } from "fs";
+import { readFile as readFile9 } from "fs/promises";
 import pc8 from "picocolors";
 var SUBCOMMANDS = [
   "install",
@@ -6889,7 +7079,13 @@ var SUBCOMMANDS = [
   "pull",
   "create",
   "dev",
+  "edit",
+  "freeze",
+  "git",
   "register",
+  "publish",
+  "unpublish",
+  "published",
   "check",
   "heal",
   "info",
@@ -6926,7 +7122,7 @@ function resolveInstalledShard(installed, identifier) {
     return false;
   });
 }
-var shardCommand = new Command6("shard").description("Manage shards \u2014 install, create, and maintain shard packages").argument("[name]", "Shard name for overview or script execution").argument("[script]", "Script name to run").argument("[args...]", "Script arguments").option("-p, --path <dir>", "Path to flint").allowUnknownOption().action(async (shorthand, script, args, options) => {
+var shardCommand = new Command5("shard").description("Manage shards \u2014 install, create, and maintain shard packages").argument("[name]", "Shard name for overview or script execution").argument("[script]", "Script name to run").argument("[args...]", "Script arguments").option("-p, --path <dir>", "Path to flint").allowUnknownOption().action(async (shorthand, script, args, options) => {
   if (!shorthand) {
     shardCommand.help();
     return;
@@ -6958,9 +7154,6 @@ Shard not found: "${shorthand}"`));
       if (counts.length > 0) {
         console.log(`  ${pc8.dim("Contents:")}  ${counts.join(", ")}`);
       }
-      if (detail2.depends.length > 0) {
-        console.log(`  ${pc8.dim("Depends:")}   ${detail2.depends.join(", ")}`);
-      }
       let scripts = [];
       try {
         scripts = await listShardScripts(flintPath, shorthand);
@@ -7022,7 +7215,7 @@ Shard not installed: "${shorthand}"`));
     handleError(err);
   }
 }).addCommand(
-  new Command6("install").description("Install a shard from a source (owner/repo or path:)").argument("<source>", "Source identifier (e.g. owner/repo, path:./local)").option("-f, --force", "Overwrite existing shard files").option("-p, --path <dir>", "Path to flint").action(async (source, options) => {
+  new Command5("install").description("Install a shard from a source (owner/repo or path:)").argument("<source>", "Source identifier (e.g. owner/repo, path:./local)").option("-f, --force", "Overwrite existing shard files").option("-p, --path <dir>", "Path to flint").action(async (source, options) => {
     try {
       const flintPath = await resolveFlint(options.path);
       if (!isSourceIdentifier(source)) {
@@ -7058,7 +7251,7 @@ Installed ${pc8.bold(result.name)}`));
     }
   })
 ).addCommand(
-  new Command6("uninstall").description("Uninstall a shard and clean up its files").argument("<name>", "Shard name (e.g. reports, living-documents)").option("-p, --path <dir>", "Path to flint").action(async (shorthand, options) => {
+  new Command5("uninstall").description("Uninstall a shard and clean up its files").argument("<name>", "Shard name (e.g. reports, living-documents)").option("-p, --path <dir>", "Path to flint").action(async (shorthand, options) => {
     try {
       const flintPath = await resolveFlint(options.path);
       const result = await uninstallShard(flintPath, shorthand);
@@ -7071,7 +7264,7 @@ Uninstalled ${pc8.bold(result.name)}`));
     }
   })
 ).addCommand(
-  new Command6("list").alias("ls").description("List installed shards").option("-s, --sources", "Show source declarations from flint.toml").option("-p, --path <dir>", "Path to flint").action(async (options) => {
+  new Command5("list").alias("ls").description("List installed shards").option("-s, --sources", "Show source declarations from flint.toml").option("-p, --path <dir>", "Path to flint").action(async (options) => {
     try {
       const flintPath = await resolveFlint(options.path);
       if (options.sources) {
@@ -7105,7 +7298,7 @@ Uninstalled ${pc8.bold(result.name)}`));
         modeMap.set(k, resolveShardMode(d) || "normal");
       }
       console.log(pc8.bold("\nInstalled shards:\n"));
-      const { execSync: execSync7 } = await import("child_process");
+      const { execSync: execSync4 } = await import("child_process");
       const gitRemotes = /* @__PURE__ */ new Map();
       for (const shard of installed) {
         if (modeMap.get(shard.name) !== "dev") continue;
@@ -7113,7 +7306,7 @@ Uninstalled ${pc8.bold(result.name)}`));
         const gitDir = join20(shardPath, ".git");
         if (!existsSync3(gitDir)) continue;
         try {
-          const url = execSync7("git remote get-url origin", { cwd: shardPath, encoding: "utf-8" }).trim();
+          const url = execSync4("git remote get-url origin", { cwd: shardPath, encoding: "utf-8" }).trim();
           const match = url.match(/(?:github\.com[/:])([\w.-]+\/[\w.-]+?)(?:\.git)?$/);
           if (match) {
             gitRemotes.set(shard.name, match[1]);
@@ -7145,7 +7338,7 @@ Uninstalled ${pc8.bold(result.name)}`));
     }
   })
 ).addCommand(
-  new Command6("update").description("Update remote shards (skips dev and custom, checks remote version)").option("-p, --path <dir>", "Path to flint").option("--reinstall", "Force re-download and reinstall all remote shards regardless of version").action(async (options) => {
+  new Command5("update").description("Update remote shards (skips dev and custom, checks remote version)").option("-p, --path <dir>", "Path to flint").option("--reinstall", "Force re-download and reinstall all remote shards regardless of version").action(async (options) => {
     try {
       const flintPath = await resolveFlint(options.path);
       const installed = await getInstalledShardsWithVersions(flintPath);
@@ -7165,11 +7358,15 @@ Uninstalled ${pc8.bold(result.name)}`));
         console.log();
         return;
       }
-      const mode = options.reinstall ? "Reinstalling" : "Checking";
-      console.log(pc8.bold(`
-${mode} ${updatable.length} shard(s)...
-`));
-      const results = await updateShards(flintPath, { reinstall: options.reinstall });
+      const mode = options.reinstall ? "Reinstalling" : "Updating";
+      const progress = createProgressDisplay(`${mode} shards`, updatable.length);
+      const results = await updateShards(flintPath, {
+        reinstall: options.reinstall,
+        onStart: (name) => progress.onStart(name),
+        onComplete: (name) => progress.onComplete(name),
+        onError: (name) => progress.onError(name)
+      });
+      progress.finish();
       const updated = results.filter((r) => r.status === "updated");
       const skippedResults = results.filter((r) => r.status === "skipped");
       const failed = results.filter((r) => r.status === "failed");
@@ -7197,7 +7394,7 @@ ${mode} ${updatable.length} shard(s)...
     }
   })
 ).addCommand(
-  new Command6("pull").description("Sync shard repos and install entries from manifest").argument("[name]", "Shard to pull (omit for all)").option("-p, --path <dir>", "Path to flint").action(async (shorthand, options) => {
+  new Command5("pull").description("Sync shard repos and install entries from manifest").argument("[name]", "Shard to pull (omit for all)").option("-p, --path <dir>", "Path to flint").action(async (shorthand, options) => {
     try {
       const flintPath = await resolveFlint(options.path);
       if (shorthand) {
@@ -7234,7 +7431,7 @@ Pulling all shard repos...
     }
   })
 ).addCommand(
-  new Command6("create").description("Scaffold a new local shard (dev or custom)").argument("<mode>", 'Shard mode: "dev" (publishable) or "custom" (workspace-specific)').argument("<name>", 'Shard name (e.g. "Bookmarks", "Code Review")').option("-s, --shorthand <id>", "Shard shorthand identifier (default: derived from name)").option("-d, --description <text>", "Shard description").option("--setup", "Include a setup-<shorthand>.md file for one-time initialization").option("--state", "Create a (Shard) state file in Mesh/Shards/").option("-p, --path <dir>", "Path to flint").action(async (mode, name, options) => {
+  new Command5("create").description("Scaffold a new local shard (dev or custom)").argument("<mode>", 'Shard mode: "dev" (publishable) or "custom" (workspace-specific)').argument("<name>", 'Shard name (e.g. "Bookmarks", "Code Review")').option("-s, --shorthand <id>", "Shard shorthand identifier (default: derived from name)").option("-d, --description <text>", "Shard description").option("--setup", "Include a setup-<shorthand>.md file for one-time initialization").option("--state", "Create a (Shard) state file in Mesh/Shards/").option("-p, --path <dir>", "Path to flint").action(async (mode, name, options) => {
     try {
       if (mode !== "dev" && mode !== "custom") {
         console.error(pc8.red(`
@@ -7274,7 +7471,7 @@ Created ${pc8.bold(result.name)} ${modeLabel}`));
     }
   })
 ).addCommand(
-  new Command6("dev").description("Clone an existing shard into a (Dev) folder for local editing").argument("<source>", "Source identifier (e.g. owner/repo, path:./local)").option("-p, --path <dir>", "Path to flint").action(async (source, options) => {
+  new Command5("dev").description("Clone an existing shard into a (Dev) folder for local editing").argument("<source>", "Source identifier (e.g. owner/repo, path:./local)").option("-p, --path <dir>", "Path to flint").action(async (source, options) => {
     try {
       const flintPath = await resolveFlint(options.path);
       if (!isSourceIdentifier(source)) {
@@ -7303,7 +7500,87 @@ Cloned ${pc8.bold(result.name)} for development`));
     }
   })
 ).addCommand(
-  new Command6("register").description("Register an existing Shards/ folder as a dev shard in flint.toml").argument("<folder>", 'Folder name inside Shards/ (e.g. "(Dev) Bookmarks")').option("-p, --path <dir>", "Path to flint").action(async (folder, options) => {
+  new Command5("edit").description("Transition a normal shard to dev mode (adds .git, renames to (Dev) prefix)").argument("<name>", "Shard name (e.g. reports, living-documents)").option("-p, --path <dir>", "Path to flint").action(async (name, options) => {
+    try {
+      const flintPath = await resolveFlint(options.path);
+      const installed = await getInstalledShardsWithVersions(flintPath);
+      const match = resolveInstalledShard(installed, name);
+      if (!match) {
+        console.error(pc8.red(`
+Shard "${name}" not found.`));
+        console.log(pc8.dim(`  Run ${pc8.cyan("flint shard list")} to see installed shards.`));
+        console.log();
+        return;
+      }
+      const declarations = await getShardDeclarations(flintPath);
+      const decl = declarations[match.name];
+      const source = decl?.source || "";
+      console.log(pc8.dim(`
+Transitioning ${match.folderName} to dev mode...`));
+      const result = await editShard(flintPath, match.folderName, source);
+      await updateGitignore(flintPath);
+      console.log(pc8.green(`
+${pc8.bold(result.name)} is now in dev mode`));
+      console.log(pc8.dim(`  Old: Shards/${result.oldFolder}`));
+      console.log(pc8.dim(`  New: ${abbreviatePath(result.path)}`));
+      console.log(pc8.dim(`  Git: initialized`));
+      console.log();
+    } catch (err) {
+      handleError(err);
+    }
+  })
+).addCommand(
+  new Command5("freeze").description("Transition a dev shard back to normal mode (removes .git, commits to parent)").argument("<name>", "Shard name (e.g. reports, living-documents)").option("-p, --path <dir>", "Path to flint").action(async (name, options) => {
+    try {
+      const flintPath = await resolveFlint(options.path);
+      const installed = await getInstalledShardsWithVersions(flintPath);
+      const match = resolveInstalledShard(installed, name);
+      if (!match) {
+        console.error(pc8.red(`
+Shard "${name}" not found.`));
+        console.log(pc8.dim(`  Run ${pc8.cyan("flint shard list")} to see installed shards.`));
+        console.log();
+        return;
+      }
+      console.log(pc8.dim(`
+Freezing ${match.folderName}...`));
+      const result = await freezeShard(flintPath, match.folderName);
+      await updateGitignore(flintPath);
+      console.log(pc8.green(`
+${pc8.bold(result.name)} is now a normal shard`));
+      console.log(pc8.dim(`  Old: Shards/${result.oldFolder}`));
+      console.log(pc8.dim(`  New: ${abbreviatePath(result.path)}`));
+      console.log(pc8.dim(`  Git: removed (now committed to parent flint)`));
+      console.log();
+    } catch (err) {
+      handleError(err);
+    }
+  })
+).addCommand(
+  new Command5("git").description("Add a git remote to a dev shard and update its source declaration").argument("<name>", "Shard name (e.g. reports, living-documents)").argument("<url>", "Git remote URL (e.g., https://github.com/org/repo.git)").option("-p, --path <dir>", "Path to flint").action(async (name, url, options) => {
+    try {
+      const flintPath = await resolveFlint(options.path);
+      const installed = await getInstalledShardsWithVersions(flintPath);
+      const match = resolveInstalledShard(installed, name);
+      if (!match) {
+        console.error(pc8.red(`
+Shard "${name}" not found.`));
+        console.log(pc8.dim(`  Run ${pc8.cyan("flint shard list")} to see installed shards.`));
+        console.log();
+        return;
+      }
+      const result = await addShardGitRemote(flintPath, match.folderName, url);
+      console.log(pc8.green(`
+Remote added to ${pc8.bold(match.folderName)}`));
+      console.log(pc8.dim(`  Remote: origin \u2192 ${url}`));
+      console.log(pc8.dim(`  Source: ${result.ownerRepo}`));
+      console.log();
+    } catch (err) {
+      handleError(err);
+    }
+  })
+).addCommand(
+  new Command5("register").description("Register an existing Shards/ folder as a dev shard in flint.toml").argument("<folder>", 'Folder name inside Shards/ (e.g. "(Dev) Bookmarks")').option("-p, --path <dir>", "Path to flint").action(async (folder, options) => {
     try {
       const flintPath = await resolveFlint(options.path);
       const result = await registerExistingShard(flintPath, folder);
@@ -7319,7 +7596,7 @@ Registered ${pc8.bold(result.name)}`));
     }
   })
 ).addCommand(
-  new Command6("info").description("Show detailed information about a shard").argument("<name>", "Shard name (e.g. reports, living-documents)").option("-p, --path <dir>", "Path to flint").action(async (identifier, options) => {
+  new Command5("info").description("Show detailed information about a shard").argument("<name>", "Shard name (e.g. reports, living-documents)").option("-p, --path <dir>", "Path to flint").action(async (identifier, options) => {
     try {
       const flintPath = await resolveFlint(options.path);
       const detail2 = await getShardInfo(flintPath, identifier);
@@ -7344,9 +7621,6 @@ Shard not found: "${identifier}"`));
         console.log(`  Mode        ${pc8.magenta("custom")}`);
       }
       console.log(`  Folder      Shards/${detail2.folderName}`);
-      if (detail2.depends.length > 0) {
-        console.log(`  Depends     ${detail2.depends.join(", ")}`);
-      }
       const counts = [];
       if (detail2.skillCount > 0) counts.push(`${detail2.skillCount} skill${detail2.skillCount !== 1 ? "s" : ""}`);
       if (detail2.templateCount > 0) counts.push(`${detail2.templateCount} template${detail2.templateCount !== 1 ? "s" : ""}`);
@@ -7368,7 +7642,7 @@ Shard not found: "${identifier}"`));
     }
   })
 ).addCommand(
-  new Command6("check").description("Check shard system integrity and report issues").option("-p, --path <dir>", "Path to flint").action(async (options) => {
+  new Command5("check").description("Check shard system integrity and report issues").option("-p, --path <dir>", "Path to flint").action(async (options) => {
     try {
       const flintPath = await resolveFlint(options.path);
       console.log(pc8.bold("\nShard Health Check\n"));
@@ -7401,7 +7675,7 @@ Shard not found: "${identifier}"`));
     }
   })
 ).addCommand(
-  new Command6("heal").description("Check and fix a shard \u2014 ensures folders, manifest, naming, and dependencies").argument("<name>", "Shard name (e.g. reports, living-documents)").option("-n, --dry-run", "Preview fixes without applying them").option("-p, --path <dir>", "Path to flint").action(async (name, options) => {
+  new Command5("heal").description("Check and fix a shard \u2014 ensures folders, manifest, naming, and declarations").argument("<name>", "Shard name (e.g. reports, living-documents)").option("-n, --dry-run", "Preview fixes without applying them").option("-p, --path <dir>", "Path to flint").action(async (name, options) => {
     try {
       const flintPath = await resolveFlint(options.path);
       const installed = await getInstalledShardsWithVersions(flintPath);
@@ -7455,7 +7729,7 @@ Healing ${match.folderName}...
     }
   })
 ).addCommand(
-  new Command6("add").description("Add a shard source to flint.toml without installing files").argument("<source>", "Source identifier (owner/repo)").option("-n, --name <name>", "Override the shard name in config").option("-p, --path <dir>", "Path to flint").action(async (source, options) => {
+  new Command5("add").description("Add a shard source to flint.toml without installing files").argument("<source>", "Source identifier (owner/repo)").option("-n, --name <name>", "Override the shard name in config").option("-p, --path <dir>", "Path to flint").action(async (source, options) => {
     try {
       const flintPath = await resolveFlint(options.path);
       const normalizedSource = source;
@@ -7479,7 +7753,7 @@ Added ${pc8.bold(shardName)}`));
     }
   })
 ).addCommand(
-  new Command6("remove").description("Remove a shard declaration from flint.toml (does not delete files)").argument("<name>", "Shard name (e.g. reports, living-documents)").option("-p, --path <dir>", "Path to flint").action(async (shorthand, options) => {
+  new Command5("remove").description("Remove a shard declaration from flint.toml (does not delete files)").argument("<name>", "Shard name (e.g. reports, living-documents)").option("-p, --path <dir>", "Path to flint").action(async (shorthand, options) => {
     try {
       const flintPath = await resolveFlint(options.path);
       await removeShardFromConfig(flintPath, shorthand);
@@ -7492,7 +7766,7 @@ Removed ${pc8.bold(shorthand)} from flint.toml`));
     }
   })
 ).addCommand(
-  new Command6("reinstall").description("Re-run install entries for a shard (useful for dev testing)").argument("<name>", "Shard name (e.g. reports, living-documents)").option("--force", "Override once entries (re-install all files)").option("-p, --path <dir>", "Path to flint").action(async (shorthand, options) => {
+  new Command5("reinstall").description("Re-run install entries for a shard (useful for dev testing)").argument("<name>", "Shard name (e.g. reports, living-documents)").option("--force", "Override once entries (re-install all files)").option("-p, --path <dir>", "Path to flint").action(async (shorthand, options) => {
     try {
       const flintPath = await resolveFlint(options.path);
       console.log(pc8.bold(`
@@ -7524,9 +7798,9 @@ Reinstalling ${shorthand}...
     }
   })
 ).addCommand(
-  new Command6("gitinit").description("Initialize git repo for a dev shard and push to a remote").argument("<name>", "Shard name (e.g. reports, living-documents)").argument("<url>", "Git remote URL (e.g., https://github.com/org/repo.git)").option("-p, --path <dir>", "Path to flint").action(async (name, url, options) => {
+  new Command5("gitinit").description("Initialize git repo for a dev shard and push to a remote").argument("<name>", "Shard name (e.g. reports, living-documents)").argument("<url>", "Git remote URL (e.g., https://github.com/org/repo.git)").option("-p, --path <dir>", "Path to flint").action(async (name, url, options) => {
     try {
-      const { execSync: execSync7 } = await import("child_process");
+      const { execSync: execSync4 } = await import("child_process");
       const flintPath = await resolveFlint(options.path);
       const installed = await getInstalledShardsWithVersions(flintPath);
       const match = resolveInstalledShard(installed, name);
@@ -7554,21 +7828,29 @@ Shard "${name}" not found.`));
       }
       const shardPath = join20(flintPath, "Shards", match.folderName);
       const gitDir = join20(shardPath, ".git");
-      if (existsSync3(gitDir)) {
-        console.error(pc8.red(`
-"${match.folderName}" already has a git repo. Use \`flint shard push\` instead.`));
-        console.log();
-        return;
+      const hasGit = existsSync3(gitDir);
+      if (hasGit) {
+        try {
+          const existing = execSync4("git remote get-url origin", { cwd: shardPath, stdio: "pipe" }).toString().trim();
+          console.error(pc8.red(`
+"${match.folderName}" already has a remote: ${existing}`));
+          console.log(pc8.dim(`  Use ${pc8.cyan("flint shard push")} instead.`));
+          console.log();
+          return;
+        } catch {
+        }
       }
       console.log(pc8.bold(`
 Initializing ${match.folderName}...
 `));
-      execSync7("git init", { cwd: shardPath, stdio: "pipe" });
-      execSync7(`git remote add origin "${url}"`, { cwd: shardPath, stdio: "pipe" });
-      execSync7("git branch -M main", { cwd: shardPath, stdio: "pipe" });
-      execSync7("git add -A", { cwd: shardPath, stdio: "pipe" });
-      execSync7('git commit -m "initial commit"', { cwd: shardPath, stdio: "pipe" });
-      execSync7("git push -u origin main", { cwd: shardPath, stdio: "inherit" });
+      if (!hasGit) {
+        execSync4("git init", { cwd: shardPath, stdio: "pipe" });
+      }
+      execSync4(`git remote add origin "${url}"`, { cwd: shardPath, stdio: "pipe" });
+      execSync4("git branch -M main", { cwd: shardPath, stdio: "pipe" });
+      execSync4("git add -A", { cwd: shardPath, stdio: "pipe" });
+      execSync4('git commit -m "initial commit"', { cwd: shardPath, stdio: "pipe" });
+      execSync4("git push -u origin main", { cwd: shardPath, stdio: "inherit" });
       console.log(pc8.green(`
   ${pc8.bold(match.folderName)} pushed to ${pc8.dim(url)}`));
       console.log();
@@ -7577,9 +7859,9 @@ Initializing ${match.folderName}...
     }
   })
 ).addCommand(
-  new Command6("push").description("Commit and push a dev shard to its remote").argument("<name>", "Shard name (e.g. reports, living-documents)").option("-m, --message <msg>", "Commit message").option("-b, --bump <level>", "Bump version in shard.yaml (patch, minor, major)").option("-p, --path <dir>", "Path to flint").action(async (name, options) => {
+  new Command5("push").description("Commit and push a dev shard to its remote").argument("<name>", "Shard name (e.g. reports, living-documents)").option("-m, --message <msg>", "Commit message").option("-b, --bump <level>", "Bump version in shard.yaml (patch, minor, major)").option("-p, --path <dir>", "Path to flint").action(async (name, options) => {
     try {
-      const { execSync: execSync7 } = await import("child_process");
+      const { execSync: execSync4 } = await import("child_process");
       const flintPath = await resolveFlint(options.path);
       const installed = await getInstalledShardsWithVersions(flintPath);
       const match = resolveInstalledShard(installed, name);
@@ -7614,15 +7896,15 @@ Shard "${name}" not found.`));
         console.log();
         return;
       }
-      const status = execSync7("git status --porcelain", { cwd: shardPath, encoding: "utf-8" }).trim();
+      const status = execSync4("git status --porcelain", { cwd: shardPath, encoding: "utf-8" }).trim();
       if (!status) {
         try {
-          const unpushed = execSync7("git log @{u}..HEAD --oneline", { cwd: shardPath, encoding: "utf-8" }).trim();
+          const unpushed = execSync4("git log @{u}..HEAD --oneline", { cwd: shardPath, encoding: "utf-8" }).trim();
           if (unpushed) {
             console.log(pc8.bold(`
 Pushing ${match.folderName}...
 `));
-            execSync7("git push", { cwd: shardPath, stdio: "inherit" });
+            execSync4("git push", { cwd: shardPath, stdio: "inherit" });
             console.log(pc8.green(`
   Pushed unpushed commits.`));
             console.log();
@@ -7644,9 +7926,9 @@ Invalid bump level "${level}". Use: patch, minor, or major.`));
           console.log();
           return;
         }
-        const { readFile: readFile11, writeFile: writeFile10 } = await import("fs/promises");
+        const { readFile: readFile12, writeFile: writeFile10 } = await import("fs/promises");
         const yamlPath = join20(shardPath, "shard.yaml");
-        const yamlContent = await readFile11(yamlPath, "utf-8");
+        const yamlContent = await readFile12(yamlPath, "utf-8");
         const versionMatch = yamlContent.match(/^version:\s*"?(\d+)\.(\d+)\.(\d+)"?/m);
         if (!versionMatch) {
           console.error(pc8.red(`
@@ -7666,13 +7948,13 @@ Could not parse version from shard.yaml.`));
       console.log(pc8.bold(`
 Pushing ${match.folderName}...
 `));
-      execSync7("git add -A", { cwd: shardPath, stdio: "pipe" });
-      execSync7(`git commit -m "${message.replace(/"/g, '\\"')}"`, { cwd: shardPath, stdio: "pipe" });
+      execSync4("git add -A", { cwd: shardPath, stdio: "pipe" });
+      execSync4(`git commit -m "${message.replace(/"/g, '\\"')}"`, { cwd: shardPath, stdio: "pipe" });
       try {
-        execSync7("git push", { cwd: shardPath, stdio: "inherit" });
+        execSync4("git push", { cwd: shardPath, stdio: "inherit" });
       } catch {
-        const branch = execSync7("git branch --show-current", { cwd: shardPath, encoding: "utf-8" }).trim();
-        execSync7(`git push -u origin ${branch}`, { cwd: shardPath, stdio: "inherit" });
+        const branch = execSync4("git branch --show-current", { cwd: shardPath, encoding: "utf-8" }).trim();
+        execSync4(`git push -u origin ${branch}`, { cwd: shardPath, stdio: "inherit" });
       }
       console.log(pc8.green(`
   ${pc8.bold(match.folderName)} pushed.`));
@@ -7683,7 +7965,261 @@ Pushing ${match.folderName}...
     }
   })
 ).addCommand(
-  new Command6("scripts").description("List executable scripts provided by a shard").argument("<name>", "Shard name (e.g. projects, living-documents)").option("-p, --path <dir>", "Path to flint").action(async (shorthand, options) => {
+  (() => {
+    const publishRuntime = resolveRuntimeSync({ cliname: "flint" });
+    const publishDevAvailable = publishRuntime.mode === "dev";
+    const REGISTRY_URL_PROD = "https://amicable-dog-262.convex.site";
+    const REGISTRY_URL_DEV = "https://grateful-sardine-809.convex.site";
+    const ORGS_URL_PROD = "https://impressive-ptarmigan-132.convex.site";
+    const ORGS_URL_DEV = "https://steady-lobster-998.convex.site";
+    const cmd = new Command5("publish").description("Publish a shard to the NUU Shard Registry (requires login)").argument("<name>", "Shard name (e.g. reports, notepad)").option("--org <slug>", "Publish as an organisation").option("-p, --path <dir>", "Path to flint");
+    if (publishDevAvailable) cmd.option("--dev", "Use dev environment");
+    cmd.action(async (name, options) => {
+      try {
+        const flintPath = await resolveFlint(options.path);
+        const installed = await getInstalledShardsWithVersions(flintPath);
+        const match = resolveInstalledShard(installed, name);
+        if (!match) {
+          console.error(pc8.red(`
+Shard "${name}" not found.`));
+          console.log(pc8.dim(`  Run ${pc8.cyan("flint shard list")} to see installed shards.`));
+          console.log();
+          process.exit(1);
+        }
+        const shardPath = join20(flintPath, "Shards", match.folderName);
+        const detail2 = await getShardInfo(flintPath, name);
+        if (!detail2) {
+          console.error(pc8.red(`
+Cannot read shard info for "${name}".`));
+          process.exit(1);
+        }
+        const declarations = await getShardDeclarations(flintPath);
+        const declaration = declarations[match.name];
+        let repo = "";
+        if (declaration?.source) {
+          const parsed = parseShardSource(declaration.source);
+          if (parsed.type === "github") {
+            repo = `${parsed.owner}/${parsed.repo}`;
+          }
+        }
+        if (!repo) {
+          try {
+            const { execSync: execSync4 } = await import("child_process");
+            const gitDir = join20(shardPath, ".git");
+            if (existsSync3(gitDir)) {
+              const remoteUrl = execSync4("git remote get-url origin", { cwd: shardPath, encoding: "utf-8" }).trim();
+              const ghMatch = remoteUrl.match(/github\.com[/:]([\w.-]+\/[\w.-]+?)(?:\.git)?$/);
+              if (ghMatch) {
+                repo = ghMatch[1];
+              }
+            }
+          } catch {
+          }
+        }
+        if (!repo) {
+          console.error(pc8.red(`
+Cannot determine repo for "${name}".`));
+          console.log(pc8.dim("  Ensure the shard has a GitHub source in flint.toml or a git remote."));
+          console.log();
+          process.exit(1);
+        }
+        let readme;
+        const readmePath = join20(shardPath, "README.md");
+        if (existsSync3(readmePath)) {
+          readme = await readFile9(readmePath, "utf-8");
+        }
+        const env = options.dev ? "dev" : publishDevAvailable ? "dev" : "prod";
+        const creds = await getValidAuth(
+          {
+            accountUrl: env === "dev" ? "https://dev-account.nuucognition.com" : "https://account.nuucognition.com",
+            authEnv: env,
+            cliname: "flint"
+          },
+          env
+        );
+        if (!creds) {
+          error(`Not logged in. Run \`flint login${env === "dev" ? " --dev" : ""}\` to authenticate.`);
+          process.exit(1);
+        }
+        let owner;
+        let author;
+        const orgSlug = options.org;
+        if (orgSlug) {
+          owner = orgSlug;
+          const orgsUrl = env === "dev" ? ORGS_URL_DEV : ORGS_URL_PROD;
+          const orgResponse = await fetch(`${orgsUrl}/api/orgs/${encodeURIComponent(orgSlug)}`, {
+            headers: {
+              "Content-Type": "application/json",
+              Authorization: `Bearer ${creds.sessionToken}`
+            }
+          });
+          if (!orgResponse.ok) {
+            if (orgResponse.status === 401 || orgResponse.status === 403) {
+              error(`You are not a member of organisation "${orgSlug}".`);
+            } else if (orgResponse.status === 404) {
+              error(`Organisation "${orgSlug}" not found.`);
+            } else {
+              error(`Failed to verify organisation "${orgSlug}" (HTTP ${orgResponse.status}).`);
+            }
+            process.exit(1);
+          }
+          const orgData = await orgResponse.json();
+          author = orgData.org?.name || orgSlug;
+        } else {
+          const repoOwner = repo.split("/")[0];
+          owner = repoOwner || creds.email.split("@")[0];
+        }
+        console.log(pc8.dim(`
+Publishing ${pc8.bold(detail2.name)} to shard registry...`));
+        const registryUrl = env === "dev" ? REGISTRY_URL_DEV : REGISTRY_URL_PROD;
+        const slug = `${owner}/${detail2.shorthand}`;
+        const response = await fetch(`${registryUrl}/api/register`, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${creds.sessionToken}`
+          },
+          body: JSON.stringify({
+            repo,
+            shorthand: detail2.shorthand,
+            owner,
+            name: detail2.name,
+            description: detail2.description,
+            readme,
+            ...author ? { author } : {}
+          })
+        });
+        const data = await response.json();
+        if (!response.ok) {
+          const msg = data.error?.message || `HTTP ${response.status}`;
+          console.error(pc8.red(`
+Failed to publish: ${msg}`));
+          console.log();
+          process.exit(1);
+        }
+        console.log(pc8.green(`
+  Published ${pc8.bold(detail2.name)} (${slug})`));
+        console.log(pc8.dim(`  Repo:  ${repo}`));
+        if (data.url) {
+          console.log(pc8.dim(`  URL:   ${data.url}`));
+        }
+        console.log();
+      } catch (err) {
+        handleError(err);
+      }
+    });
+    return cmd;
+  })()
+).addCommand(
+  (() => {
+    const unpubRuntime = resolveRuntimeSync({ cliname: "flint" });
+    const unpubDevAvailable = unpubRuntime.mode === "dev";
+    const REGISTRY_URL_PROD = "https://amicable-dog-262.convex.site";
+    const REGISTRY_URL_DEV = "https://grateful-sardine-809.convex.site";
+    const cmd = new Command5("unpublish").description("Remove a shard from the NUU Shard Registry (requires login)").argument("<slug>", "Shard slug (e.g. NUU-Cognition/notepad)").option("-p, --path <dir>", "Path to flint");
+    if (unpubDevAvailable) cmd.option("--dev", "Use dev environment");
+    cmd.action(async (slug, options) => {
+      try {
+        const env = options.dev ? "dev" : unpubDevAvailable ? "dev" : "prod";
+        const creds = await getValidAuth(
+          {
+            accountUrl: env === "dev" ? "https://dev-account.nuucognition.com" : "https://account.nuucognition.com",
+            authEnv: env,
+            cliname: "flint"
+          },
+          env
+        );
+        if (!creds) {
+          error(`Not logged in. Run \`flint login${env === "dev" ? " --dev" : ""}\` to authenticate.`);
+          process.exit(1);
+        }
+        console.log(pc8.dim(`
+Unpublishing ${pc8.bold(slug)} from shard registry...`));
+        const registryUrl = env === "dev" ? REGISTRY_URL_DEV : REGISTRY_URL_PROD;
+        const response = await fetch(`${registryUrl}/api/register`, {
+          method: "DELETE",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${creds.sessionToken}`
+          },
+          body: JSON.stringify({ slug })
+        });
+        const data = await response.json();
+        if (!response.ok) {
+          const msg = data.error?.message || `HTTP ${response.status}`;
+          console.error(pc8.red(`
+Failed to unpublish: ${msg}`));
+          console.log();
+          process.exit(1);
+        }
+        success(`Unpublished ${pc8.bold(slug)} from shard registry.`);
+        console.log();
+      } catch (err) {
+        handleError(err);
+      }
+    });
+    return cmd;
+  })()
+).addCommand(
+  (() => {
+    const pubListRuntime = resolveRuntimeSync({ cliname: "flint" });
+    const pubListDevAvailable = pubListRuntime.mode === "dev";
+    const REGISTRY_URL_PROD = "https://amicable-dog-262.convex.site";
+    const REGISTRY_URL_DEV = "https://grateful-sardine-809.convex.site";
+    const cmd = new Command5("published").description("List your published shards on the NUU Shard Registry");
+    if (pubListDevAvailable) cmd.option("--dev", "Use dev environment");
+    cmd.action(async (options) => {
+      try {
+        const env = options.dev ? "dev" : pubListDevAvailable ? "dev" : "prod";
+        const creds = await getValidAuth(
+          {
+            accountUrl: env === "dev" ? "https://dev-account.nuucognition.com" : "https://account.nuucognition.com",
+            authEnv: env,
+            cliname: "flint"
+          },
+          env
+        );
+        if (!creds) {
+          error(`Not logged in. Run \`flint login${env === "dev" ? " --dev" : ""}\` to authenticate.`);
+          process.exit(1);
+        }
+        const registryUrl = env === "dev" ? REGISTRY_URL_DEV : REGISTRY_URL_PROD;
+        const response = await fetch(`${registryUrl}/api/my-shards`, {
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${creds.sessionToken}`
+          }
+        });
+        if (!response.ok) {
+          const data2 = await response.json();
+          const msg = data2.error?.message || `HTTP ${response.status}`;
+          console.error(pc8.red(`
+Failed to fetch published shards: ${msg}`));
+          console.log();
+          process.exit(1);
+        }
+        const data = await response.json();
+        if (!data.shards.length) {
+          console.log(pc8.dim("\nNo published shards found."));
+          console.log(pc8.dim(`  Run ${pc8.cyan("flint shard publish <name>")} to publish a shard.`));
+          console.log();
+          return;
+        }
+        console.log(pc8.dim(`
+  ${data.shards.length} published shard${data.shards.length === 1 ? "" : "s"}:
+`));
+        for (const s of data.shards) {
+          console.log(`  ${pc8.bold(s.name)}  ${pc8.dim(s.slug)}  ${pc8.dim(s.repo)}`);
+        }
+        console.log();
+      } catch (err) {
+        handleError(err);
+      }
+    });
+    return cmd;
+  })()
+).addCommand(
+  new Command5("scripts").description("List executable scripts provided by a shard").argument("<name>", "Shard name (e.g. projects, living-documents)").option("-p, --path <dir>", "Path to flint").action(async (shorthand, options) => {
     try {
       const flintPath = await resolveFlint(options.path);
       const scripts = await listShardScripts(flintPath, shorthand);
@@ -7709,7 +8245,7 @@ Scripts for ${shorthand}:
 );
 
 // src/commands/mod.ts
-import { Command as Command7 } from "commander";
+import { Command as Command6 } from "commander";
 import { spawn as spawn3 } from "child_process";
 import { join as join21 } from "path";
 import { existsSync as existsSync4 } from "fs";
@@ -7760,7 +8296,7 @@ function resolveInstalledMod(installed, identifier) {
     return false;
   });
 }
-var modCommand = new Command7("mod").description("Manage mods \u2014 install, create, and maintain mod packages").argument("[identifier]", "Mod identifier for script execution").argument("[script]", "Script name to run").argument("[args...]", "Script arguments").option("-p, --path <dir>", "Path to flint").allowUnknownOption().action(async (identifier, script, args, options) => {
+var modCommand = new Command6("mod").description("Manage mods \u2014 install, create, and maintain mod packages").argument("[identifier]", "Mod identifier for script execution").argument("[script]", "Script name to run").argument("[args...]", "Script arguments").option("-p, --path <dir>", "Path to flint").allowUnknownOption().action(async (identifier, script, args, options) => {
   if (!identifier) {
     modCommand.help();
     return;
@@ -7854,7 +8390,7 @@ Mod not installed: "${identifier}"`));
     handleError2(err);
   }
 }).addCommand(
-  new Command7("install").description("Install a mod from a source (owner/repo, path:, or builtin shorthand)").argument("<source>", "Source identifier (e.g. owner/repo, path:./local, or builtin shorthand like cc)").option("-f, --force", "Overwrite existing files").option("-p, --path <dir>", "Path to flint").action(async (source, options) => {
+  new Command6("install").description("Install a mod from a source (owner/repo, path:, or builtin shorthand)").argument("<source>", "Source identifier (e.g. owner/repo, path:./local, or builtin shorthand like cc)").option("-f, --force", "Overwrite existing files").option("-p, --path <dir>", "Path to flint").action(async (source, options) => {
     try {
       const flintPath = await resolveFlint2(options.path);
       if (isSourceIdentifier2(source)) {
@@ -7920,7 +8456,7 @@ Installed ${pc9.bold(result.name)}`));
     }
   })
 ).addCommand(
-  new Command7("uninstall").description("Uninstall a mod and clean up its files").argument("<shorthand>", "Mod shorthand or name").option("-p, --path <dir>", "Path to flint").action(async (shorthand, options) => {
+  new Command6("uninstall").description("Uninstall a mod and clean up its files").argument("<shorthand>", "Mod shorthand or name").option("-p, --path <dir>", "Path to flint").action(async (shorthand, options) => {
     try {
       const flintPath = await resolveFlint2(options.path);
       const result = await uninstallMod(flintPath, shorthand);
@@ -7933,7 +8469,7 @@ Uninstalled ${pc9.bold(result.name)}`));
     }
   })
 ).addCommand(
-  new Command7("list").alias("ls").description("List installed or available mods").option("-a, --available", "Show mods available to install").option("-s, --sources", "Show source declarations from flint.toml").option("-p, --path <dir>", "Path to flint").action(async (options) => {
+  new Command6("list").alias("ls").description("List installed or available mods").option("-a, --available", "Show mods available to install").option("-s, --sources", "Show source declarations from flint.toml").option("-p, --path <dir>", "Path to flint").action(async (options) => {
     try {
       if (options.available) {
         const available = await listAvailableMods();
@@ -7984,7 +8520,7 @@ Uninstalled ${pc9.bold(result.name)}`));
         Object.entries(declarations).filter(([, d]) => d.dev).map(([k]) => k)
       );
       console.log(pc9.bold("\nInstalled mods:\n"));
-      const { execSync: execSync7 } = await import("child_process");
+      const { execSync: execSync4 } = await import("child_process");
       const gitRemotes = /* @__PURE__ */ new Map();
       for (const mod of installed) {
         const kebab = toKebabCase(mod.name);
@@ -7993,7 +8529,7 @@ Uninstalled ${pc9.bold(result.name)}`));
         const gitDir = join21(modPath, ".git");
         if (!existsSync4(gitDir)) continue;
         try {
-          const url = execSync7("git remote get-url origin", { cwd: modPath, encoding: "utf-8" }).trim();
+          const url = execSync4("git remote get-url origin", { cwd: modPath, encoding: "utf-8" }).trim();
           const match = url.match(/(?:github\.com[/:])([\w.-]+\/[\w.-]+?)(?:\.git)?$/);
           if (match) {
             gitRemotes.set(mod.name, match[1]);
@@ -8023,7 +8559,7 @@ Uninstalled ${pc9.bold(result.name)}`));
     }
   })
 ).addCommand(
-  new Command7("update").description("Update non-dev mods (use --reinstall to force)").option("-p, --path <dir>", "Path to flint").option("--reinstall", "Force reinstall all non-dev mods").action(async (options) => {
+  new Command6("update").description("Update non-dev mods (use --reinstall to force)").option("-p, --path <dir>", "Path to flint").option("--reinstall", "Force reinstall all non-dev mods").action(async (options) => {
     try {
       const flintPath = await resolveFlint2(options.path);
       const installed = await getInstalledMods(flintPath);
@@ -8076,7 +8612,7 @@ ${mode} ${updatable.length} mod(s)...
     }
   })
 ).addCommand(
-  new Command7("pull").description("Sync mod repos and install entries from manifest").argument("[identifier]", "Mod to pull (omit for all)").option("-p, --path <dir>", "Path to flint").action(async (identifier, options) => {
+  new Command6("pull").description("Sync mod repos and install entries from manifest").argument("[identifier]", "Mod to pull (omit for all)").option("-p, --path <dir>", "Path to flint").action(async (identifier, options) => {
     try {
       const flintPath = await resolveFlint2(options.path);
       if (identifier) {
@@ -8113,7 +8649,7 @@ Pulling all mod repos...
     }
   })
 ).addCommand(
-  new Command7("create").description("Scaffold a new dev mod with standard structure").argument("<name>", 'Mod name (e.g. "Obsidian", "Docker")').option("-s, --shorthand <id>", "Mod shorthand identifier (default: derived from name)").option("-d, --description <text>", "Mod description").option("-p, --path <dir>", "Path to flint").action(async (name, options) => {
+  new Command6("create").description("Scaffold a new dev mod with standard structure").argument("<name>", 'Mod name (e.g. "Obsidian", "Docker")').option("-s, --shorthand <id>", "Mod shorthand identifier (default: derived from name)").option("-d, --description <text>", "Mod description").option("-p, --path <dir>", "Path to flint").action(async (name, options) => {
     try {
       const flintPath = await resolveFlint2(options.path);
       const shorthand = options.shorthand || name.split(/\s+/).map((w) => w[0]).join("").toLowerCase().slice(0, 4) || name.toLowerCase().replace(/\s+/g, "").slice(0, 4);
@@ -8135,7 +8671,7 @@ Created ${pc9.bold(result.name)}`));
     }
   })
 ).addCommand(
-  new Command7("dev").description("Clone an existing mod into a (Dev) folder for local editing").argument("<source>", "Source identifier (e.g. owner/repo, path:./local, or builtin shorthand like cc)").option("-p, --path <dir>", "Path to flint").action(async (source, options) => {
+  new Command6("dev").description("Clone an existing mod into a (Dev) folder for local editing").argument("<source>", "Source identifier (e.g. owner/repo, path:./local, or builtin shorthand like cc)").option("-p, --path <dir>", "Path to flint").action(async (source, options) => {
     try {
       const flintPath = await resolveFlint2(options.path);
       if (isSourceIdentifier2(source)) {
@@ -8172,31 +8708,18 @@ Cloned ${pc9.bold(result.name)} for development`));
           await cleanupResolvedModSource(resolved);
         }
       } else {
-        const mod = await getBuiltinMod(source);
-        if (!mod) {
-          const available = await listAvailableMods();
-          const shorthands = available.map((m) => m.shorthand).join(", ");
-          console.error(pc9.red(`
-Unknown mod: "${source}"`));
-          console.log(pc9.dim(`  Available: ${shorthands}`));
-          console.log();
-          process.exit(1);
-        }
-        console.log(pc9.dim(`
-Cloning ${mod.name}...`));
-        const result = await cloneModToDev(flintPath, mod.path, mod);
-        await updateGitignore(flintPath);
-        console.log(pc9.green(`
-Cloned ${pc9.bold(result.name)} for development`));
-        console.log(pc9.dim(`  Path: ${abbreviatePath(result.path)}`));
+        console.error(pc9.red(`
+Unknown mod source: "${source}"`));
+        console.log(pc9.dim(`  Provide an owner/repo source (e.g., "NUU-Cognition/flint-mod-agents")`));
         console.log();
+        process.exit(1);
       }
     } catch (err) {
       handleError2(err);
     }
   })
 ).addCommand(
-  new Command7("register").description("Register an existing Mods/ folder as a dev mod in flint.toml").argument("<folder>", 'Folder name inside Mods/ (e.g., "(Dev) Docker")').option("-p, --path <dir>", "Path to flint").action(async (folder, options) => {
+  new Command6("register").description("Register an existing Mods/ folder as a dev mod in flint.toml").argument("<folder>", 'Folder name inside Mods/ (e.g., "(Dev) Docker")').option("-p, --path <dir>", "Path to flint").action(async (folder, options) => {
     try {
       const flintPath = await resolveFlint2(options.path);
       const result = await registerExistingMod(flintPath, folder);
@@ -8212,7 +8735,7 @@ Registered ${pc9.bold(result.name)}`));
     }
   })
 ).addCommand(
-  new Command7("info").description("Show detailed information about a mod").argument("<name>", "Mod shorthand, name, or folder name").option("-p, --path <dir>", "Path to flint").action(async (identifier, options) => {
+  new Command6("info").description("Show detailed information about a mod").argument("<name>", "Mod shorthand, name, or folder name").option("-p, --path <dir>", "Path to flint").action(async (identifier, options) => {
     try {
       const flintPath = await resolveFlint2(options.path);
       const detail2 = await getModInfo(flintPath, identifier);
@@ -8266,7 +8789,7 @@ Mod not found: "${identifier}"`));
     }
   })
 ).addCommand(
-  new Command7("check").description("Check mod system integrity and report issues").option("-p, --path <dir>", "Path to flint").action(async (options) => {
+  new Command6("check").description("Check mod system integrity and report issues").option("-p, --path <dir>", "Path to flint").action(async (options) => {
     try {
       const flintPath = await resolveFlint2(options.path);
       console.log(pc9.bold("\nMod Health Check\n"));
@@ -8299,7 +8822,7 @@ Mod not found: "${identifier}"`));
     }
   })
 ).addCommand(
-  new Command7("heal").description("Check and fix a mod \u2014 ensures folders, manifest, naming, and dependencies").argument("<name>", "Mod name (e.g. claude-code, agents)").option("-n, --dry-run", "Preview fixes without applying them").option("-p, --path <dir>", "Path to flint").action(async (name, options) => {
+  new Command6("heal").description("Check and fix a mod \u2014 ensures folders, manifest, naming, and dependencies").argument("<name>", "Mod name (e.g. claude-code, agents)").option("-n, --dry-run", "Preview fixes without applying them").option("-p, --path <dir>", "Path to flint").action(async (name, options) => {
     try {
       const flintPath = await resolveFlint2(options.path);
       const installed = await getInstalledMods(flintPath);
@@ -8353,7 +8876,7 @@ Healing ${match.folderName}...
     }
   })
 ).addCommand(
-  new Command7("add").description("Add a mod to flint.toml without installing files").argument("<source>", "Mod source (owner/repo, path:./local, or builtin shorthand)").option("-p, --path <dir>", "Path to flint").action(async (source, options) => {
+  new Command6("add").description("Add a mod to flint.toml without installing files").argument("<source>", "Mod source (owner/repo, path:./local, or builtin shorthand)").option("-p, --path <dir>", "Path to flint").action(async (source, options) => {
     try {
       const flintPath = await resolveFlint2(options.path);
       let modName;
@@ -8376,7 +8899,7 @@ Added ${pc9.bold(modName)}`));
     }
   })
 ).addCommand(
-  new Command7("remove").description("Remove a mod declaration from flint.toml (does not delete files)").argument("<name>", "Mod name").option("-p, --path <dir>", "Path to flint").action(async (name, options) => {
+  new Command6("remove").description("Remove a mod declaration from flint.toml (does not delete files)").argument("<name>", "Mod name").option("-p, --path <dir>", "Path to flint").action(async (name, options) => {
     try {
       const flintPath = await resolveFlint2(options.path);
       await removeModFromConfig(flintPath, name);
@@ -8389,7 +8912,7 @@ Removed ${pc9.bold(name)} from flint.toml`));
     }
   })
 ).addCommand(
-  new Command7("reinstall").description("Re-run install entries for a mod (useful for dev testing)").argument("<shorthand>", "Mod shorthand or name").option("--force", "Override once entries (re-install all files)").option("-p, --path <dir>", "Path to flint").action(async (shorthand, options) => {
+  new Command6("reinstall").description("Re-run install entries for a mod (useful for dev testing)").argument("<shorthand>", "Mod shorthand or name").option("--force", "Override once entries (re-install all files)").option("-p, --path <dir>", "Path to flint").action(async (shorthand, options) => {
     try {
       const flintPath = await resolveFlint2(options.path);
       console.log(pc9.bold(`
@@ -8421,9 +8944,9 @@ Reinstalling ${shorthand}...
     }
   })
 ).addCommand(
-  new Command7("gitinit").description("Initialize git repo for a dev mod and push to a remote").argument("<name>", "Mod name (e.g. claude-code, agents)").argument("<url>", "Git remote URL (e.g., https://github.com/org/repo.git)").option("-p, --path <dir>", "Path to flint").action(async (name, url, options) => {
+  new Command6("gitinit").description("Initialize git repo for a dev mod and push to a remote").argument("<name>", "Mod name (e.g. claude-code, agents)").argument("<url>", "Git remote URL (e.g., https://github.com/org/repo.git)").option("-p, --path <dir>", "Path to flint").action(async (name, url, options) => {
     try {
-      const { execSync: execSync7 } = await import("child_process");
+      const { execSync: execSync4 } = await import("child_process");
       const flintPath = await resolveFlint2(options.path);
       const installed = await getInstalledMods(flintPath);
       const match = resolveInstalledMod(installed, name);
@@ -8453,12 +8976,12 @@ Mod "${name}" not found.`));
       console.log(pc9.bold(`
 Initializing ${match.folderName}...
 `));
-      execSync7("git init", { cwd: modPath, stdio: "pipe" });
-      execSync7(`git remote add origin "${url}"`, { cwd: modPath, stdio: "pipe" });
-      execSync7("git branch -M main", { cwd: modPath, stdio: "pipe" });
-      execSync7("git add -A", { cwd: modPath, stdio: "pipe" });
-      execSync7('git commit -m "initial commit"', { cwd: modPath, stdio: "pipe" });
-      execSync7("git push -u origin main", { cwd: modPath, stdio: "inherit" });
+      execSync4("git init", { cwd: modPath, stdio: "pipe" });
+      execSync4(`git remote add origin "${url}"`, { cwd: modPath, stdio: "pipe" });
+      execSync4("git branch -M main", { cwd: modPath, stdio: "pipe" });
+      execSync4("git add -A", { cwd: modPath, stdio: "pipe" });
+      execSync4('git commit -m "initial commit"', { cwd: modPath, stdio: "pipe" });
+      execSync4("git push -u origin main", { cwd: modPath, stdio: "inherit" });
       console.log(pc9.green(`
   ${pc9.bold(match.folderName)} pushed to ${pc9.dim(url)}`));
       console.log();
@@ -8467,9 +8990,9 @@ Initializing ${match.folderName}...
     }
   })
 ).addCommand(
-  new Command7("push").description("Commit and push a dev mod to its remote").argument("<name>", "Mod name (e.g. claude-code, agents)").option("-m, --message <msg>", "Commit message").option("-p, --path <dir>", "Path to flint").action(async (name, options) => {
+  new Command6("push").description("Commit and push a dev mod to its remote").argument("<name>", "Mod name (e.g. claude-code, agents)").option("-m, --message <msg>", "Commit message").option("-p, --path <dir>", "Path to flint").action(async (name, options) => {
     try {
-      const { execSync: execSync7 } = await import("child_process");
+      const { execSync: execSync4 } = await import("child_process");
       const flintPath = await resolveFlint2(options.path);
       const installed = await getInstalledMods(flintPath);
       const match = resolveInstalledMod(installed, name);
@@ -8497,15 +9020,15 @@ Mod "${name}" not found.`));
         console.log();
         return;
       }
-      const status = execSync7("git status --porcelain", { cwd: modPath, encoding: "utf-8" }).trim();
+      const status = execSync4("git status --porcelain", { cwd: modPath, encoding: "utf-8" }).trim();
       if (!status) {
         try {
-          const unpushed = execSync7("git log @{u}..HEAD --oneline", { cwd: modPath, encoding: "utf-8" }).trim();
+          const unpushed = execSync4("git log @{u}..HEAD --oneline", { cwd: modPath, encoding: "utf-8" }).trim();
           if (unpushed) {
             console.log(pc9.bold(`
 Pushing ${match.folderName}...
 `));
-            execSync7("git push", { cwd: modPath, stdio: "inherit" });
+            execSync4("git push", { cwd: modPath, stdio: "inherit" });
             console.log(pc9.green(`
   Pushed unpushed commits.`));
             console.log();
@@ -8522,13 +9045,13 @@ No changes to push in "${match.folderName}".`));
       console.log(pc9.bold(`
 Pushing ${match.folderName}...
 `));
-      execSync7("git add -A", { cwd: modPath, stdio: "pipe" });
-      execSync7(`git commit -m "${message.replace(/"/g, '\\"')}"`, { cwd: modPath, stdio: "pipe" });
+      execSync4("git add -A", { cwd: modPath, stdio: "pipe" });
+      execSync4(`git commit -m "${message.replace(/"/g, '\\"')}"`, { cwd: modPath, stdio: "pipe" });
       try {
-        execSync7("git push", { cwd: modPath, stdio: "inherit" });
+        execSync4("git push", { cwd: modPath, stdio: "inherit" });
       } catch {
-        const branch = execSync7("git branch --show-current", { cwd: modPath, encoding: "utf-8" }).trim();
-        execSync7(`git push -u origin ${branch}`, { cwd: modPath, stdio: "inherit" });
+        const branch = execSync4("git branch --show-current", { cwd: modPath, encoding: "utf-8" }).trim();
+        execSync4(`git push -u origin ${branch}`, { cwd: modPath, stdio: "inherit" });
       }
       console.log(pc9.green(`
   ${pc9.bold(match.folderName)} pushed.`));
@@ -8539,7 +9062,7 @@ Pushing ${match.folderName}...
     }
   })
 ).addCommand(
-  new Command7("scripts").description("List executable scripts provided by a mod").argument("<identifier>", "Mod shorthand (e.g., cc)").option("-p, --path <dir>", "Path to flint").action(async (identifier, options) => {
+  new Command6("scripts").description("List executable scripts provided by a mod").argument("<identifier>", "Mod shorthand (e.g., cc)").option("-p, --path <dir>", "Path to flint").action(async (identifier, options) => {
     try {
       const flintPath = await resolveFlint2(options.path);
       const scripts = await listModScripts(flintPath, identifier);
@@ -8565,9 +9088,9 @@ Scripts for ${identifier}:
 );
 
 // src/commands/sync.ts
-import { Command as Command8 } from "commander";
+import { Command as Command7 } from "commander";
 import pc10 from "picocolors";
-var syncCommand = new Command8("sync").description("Sync shards and mods from flint.toml").option("-p, --path <dir>", "Path to flint (default: auto-detect)").action(async (options) => {
+var syncCommand = new Command7("sync").description("Sync shards and mods from flint.toml").option("-p, --path <dir>", "Path to flint (default: auto-detect)").action(async (options) => {
   try {
     const flintPath = options.path || await findFlintRoot(process.cwd());
     if (!flintPath) {
@@ -8577,7 +9100,39 @@ var syncCommand = new Command8("sync").description("Sync shards and mods from fl
       process.exit(1);
     }
     console.log(pc10.bold("\nSyncing flint...\n"));
-    const result = await syncFlint(flintPath);
+    let shardProgress;
+    let modProgress;
+    const progress = {
+      onShardPhase(total) {
+        if (total > 0) {
+          shardProgress = createProgressDisplay("Installing shards", total);
+        }
+      },
+      onShardStart(name) {
+        shardProgress?.onStart(name);
+      },
+      onShardDone(name, ok) {
+        if (ok) shardProgress?.onComplete(name);
+        else shardProgress?.onError(name);
+      },
+      onModPhase(total) {
+        shardProgress?.finish();
+        if (total > 0) {
+          console.log();
+          modProgress = createProgressDisplay("Installing mods", total);
+        }
+      },
+      onModStart(name) {
+        modProgress?.onStart(name);
+      },
+      onModDone(name, ok) {
+        if (ok) modProgress?.onComplete(name);
+        else modProgress?.onError(name);
+      }
+    };
+    const result = await syncFlint(flintPath, progress);
+    shardProgress?.finish();
+    modProgress?.finish();
     if (result.bootstrap.created) {
       console.log(pc10.green("Bootstrap:"));
       console.log(`  ${pc10.green("+")} Created .flint/ directory`);
@@ -8616,12 +9171,6 @@ var syncCommand = new Command8("sync").description("Sync shards and mods from fl
     }
     const hasShardChanges = result.shards.installed.length > 0 || result.shards.uninstalled.length > 0 || result.shards.orphaned.length > 0;
     const hasModChanges = result.mods.installed.length > 0 || result.mods.uninstalled.length > 0;
-    if (result.shards.installed.length > 0) {
-      console.log(pc10.green("Shards installed:"));
-      for (const s of result.shards.installed) {
-        console.log(`  ${pc10.green("+")} ${s}`);
-      }
-    }
     if (result.shards.uninstalled.length > 0) {
       console.log(pc10.yellow("Shards removed:"));
       for (const s of result.shards.uninstalled) {
@@ -8635,12 +9184,6 @@ var syncCommand = new Command8("sync").description("Sync shards and mods from fl
       }
       console.log(pc10.dim("  Run `flint shard uninstall <shorthand>` to remove"));
     }
-    if (result.mods.installed.length > 0) {
-      console.log(pc10.green("Mods installed:"));
-      for (const s of result.mods.installed) {
-        console.log(`  ${pc10.green("+")} ${s}`);
-      }
-    }
     if (result.mods.uninstalled.length > 0) {
       console.log(pc10.yellow("Mods removed:"));
       for (const s of result.mods.uninstalled) {
@@ -8683,6 +9226,9 @@ var syncCommand = new Command8("sync").description("Sync shards and mods from fl
           case "not_found":
             console.log(`  ${pc10.yellow("\u26A0")} ${imp.ref} - flint not found in registry`);
             break;
+          case "export_not_found":
+            console.log(`  ${pc10.yellow("\u26A0")} ${imp.ref} - ${imp.error}`);
+            break;
           case "not_built":
             console.log(`  ${pc10.yellow("\u26A0")} ${imp.ref} - export not built`);
             break;
@@ -8740,9 +9286,9 @@ var syncCommand = new Command8("sync").description("Sync shards and mods from fl
 });
 
 // src/commands/git.ts
-import { Command as Command9 } from "commander";
+import { Command as Command8 } from "commander";
 import pc11 from "picocolors";
-var gitCommand = new Command9("git").description("Git operations for the Flint").enablePositionalOptions().passThroughOptions().option("-p, --path <dir>", "Path to flint (default: auto-detect)").argument("[args...]", "Git arguments").action(async (args, options) => {
+var gitCommand = new Command8("git").description("Git operations for the Flint").enablePositionalOptions().passThroughOptions().option("-p, --path <dir>", "Path to flint (default: auto-detect)").argument("[args...]", "Git arguments").action(async (args, options) => {
   const flintPath = options.path || await findFlintRoot(process.cwd());
   if (!flintPath) {
     console.error(pc11.red("Error: Not inside a Flint."));
@@ -8768,21 +9314,19 @@ var gitCommand = new Command9("git").description("Git operations for the Flint")
   }
 });
 async function handleInit(flintPath) {
-  const modInstalled = await isModInstalled(flintPath, "git");
-  if (modInstalled) {
-    const initialized = await isGitInitialized(flintPath);
-    if (initialized) {
-      console.log(pc11.yellow("Git already initialized. Updating .gitignore..."));
-      await updateGitignore(flintPath);
-      console.log(pc11.green("Updated .gitignore"));
-    } else {
-      console.log(pc11.yellow("Git mod installed but git not initialized. Run `git init` manually."));
-    }
+  const initialized = await isGitInitialized(flintPath);
+  if (initialized) {
+    console.log(pc11.yellow("Git already initialized. Updating .gitignore..."));
+    await updateGitignore(flintPath);
+    console.log(pc11.green("Updated .gitignore"));
     return;
   }
   try {
-    console.log(pc11.dim("Installing git mod..."));
-    await installMod(flintPath, "git", { source: "NUU-Cognition/flint-mod-git" });
+    const result = await initGit(flintPath);
+    if (!result.success) {
+      console.error(pc11.red(`Error: ${result.error}`));
+      process.exit(1);
+    }
     console.log(pc11.green("Initialized git repository"));
     console.log(pc11.dim("Created .gitignore with Flint defaults"));
   } catch (err) {
@@ -8808,23 +9352,21 @@ async function handleGitInit(flintPath, args) {
     console.log(pc11.dim("Usage: flint git gitinit <repolink>"));
     process.exit(1);
   }
-  const modInstalled = await isModInstalled(flintPath, "git");
-  if (!modInstalled) {
+  const initialized = await isGitInitialized(flintPath);
+  if (!initialized) {
     try {
-      console.log(pc11.dim("Installing git mod..."));
-      await installMod(flintPath, "git", { source: "NUU-Cognition/flint-mod-git" });
+      const result = await initGit(flintPath);
+      if (!result.success) {
+        console.error(pc11.red(`Failed to initialize git: ${result.error}`));
+        process.exit(1);
+      }
       console.log(pc11.green("\u2713 Initialized git repository"));
     } catch (err) {
-      console.error(pc11.red(`Failed to install git mod: ${err instanceof Error ? err.message : String(err)}`));
+      console.error(pc11.red(`Failed to initialize git: ${err instanceof Error ? err.message : String(err)}`));
       process.exit(1);
     }
   } else {
-    const initialized = await isGitInitialized(flintPath);
-    if (!initialized) {
-      console.error(pc11.red("Git mod installed but git not initialized. Run `git init` manually."));
-      process.exit(1);
-    }
-    console.log(pc11.dim("Git mod already installed."));
+    console.log(pc11.dim("Git already initialized."));
   }
   try {
     console.log(pc11.dim("Syncing flint..."));
@@ -8914,9 +9456,9 @@ async function showFlintGitStatus(flintPath) {
 }
 
 // src/commands/repair.ts
-import { Command as Command10 } from "commander";
+import { Command as Command9 } from "commander";
 import pc12 from "picocolors";
-import { mkdir as mkdir12, access as access8 } from "fs/promises";
+import { mkdir as mkdir12, access as access7 } from "fs/promises";
 import { join as join24, basename as basename2 } from "path";
 var REQUIRED_DIRS = [
   "Mesh",
@@ -8930,7 +9472,7 @@ var REQUIRED_DIRS = [
 ];
 async function exists2(path3) {
   try {
-    await access8(path3);
+    await access7(path3);
     return true;
   } catch {
     return false;
@@ -9063,7 +9605,7 @@ function printResults(title, results) {
   }
   console.log();
 }
-var repairCommand = new Command10("repair").description("Repair a flint to match current specifications").option("-p, --path <dir>", "Path to flint (default: auto-detect)").option("-n, --dry-run", "Show what would be fixed without making changes").action(async (options) => {
+var repairCommand = new Command9("repair").description("Repair a flint to match current specifications").option("-p, --path <dir>", "Path to flint (default: auto-detect)").option("-n, --dry-run", "Show what would be fixed without making changes").action(async (options) => {
   try {
     const flintPath = options.path || await findFlintRoot(process.cwd());
     if (!flintPath) {
@@ -9151,9 +9693,9 @@ var repairCommand = new Command10("repair").description("Repair a flint to match
 });
 
 // src/commands/export.ts
-import { Command as Command11 } from "commander";
+import { Command as Command10 } from "commander";
 import pc13 from "picocolors";
-import { readFile as readFile9, stat as stat7 } from "fs/promises";
+import { readFile as readFile10, stat as stat7 } from "fs/promises";
 import { join as join25, basename as basename4 } from "path";
 import { createInterface as createInterface2 } from "readline";
 async function exists3(path3) {
@@ -9208,7 +9750,7 @@ async function getExportStatus(flintPath) {
         if (!await exists3(manifestPath)) {
           manifestPath = join25(flintPath, "Exports", manifest.name, "_manifest.json");
         }
-        const manifestJson = JSON.parse(await readFile9(manifestPath, "utf-8"));
+        const manifestJson = JSON.parse(await readFile10(manifestPath, "utf-8"));
         fileCount = manifestJson.files?.length || 0;
       } catch {
       }
@@ -9222,7 +9764,7 @@ async function getExportStatus(flintPath) {
   }
   return results;
 }
-var listCommand2 = new Command11("list").description("List all declared exports").option("-p, --path <dir>", "Path to flint (default: auto-detect)").action(async (options) => {
+var listCommand2 = new Command10("list").description("List all declared exports").option("-p, --path <dir>", "Path to flint (default: auto-detect)").action(async (options) => {
   try {
     const flintPath = options.path || await findFlintRoot(process.cwd());
     if (!flintPath) {
@@ -9259,7 +9801,7 @@ var listCommand2 = new Command11("list").description("List all declared exports"
     process.exit(1);
   }
 });
-var scanCommand = new Command11("scan").description("Find #export-tagged files not yet declared").option("-p, --path <dir>", "Path to flint (default: auto-detect)").action(async (options) => {
+var scanCommand = new Command10("scan").description("Find #export-tagged files not yet declared").option("-p, --path <dir>", "Path to flint (default: auto-detect)").action(async (options) => {
   try {
     const flintPath = options.path || await findFlintRoot(process.cwd());
     if (!flintPath) {
@@ -9301,9 +9843,23 @@ var scanCommand = new Command11("scan").description("Find #export-tagged files n
       });
       console.log(`    ${pc13.green("\u2713")} Added ${pc13.cyan(exportName)}`);
     }
+    const manifests = await scanExports(flintPath);
+    if (manifests.length > 0) {
+      console.log();
+      console.log(pc13.bold("Building exports..."));
+      console.log();
+      const removed = await cleanupStaleExports(flintPath);
+      for (const r of removed) {
+        console.log(`  ${pc13.yellow("-")} ${r} ${pc13.dim("(removed stale)")}`);
+      }
+      for (const manifest of manifests) {
+        const result = await buildExport(manifest, flintPath);
+        console.log(`  ${pc13.green("\u2713")} Built ${pc13.cyan(result.name)} \u2014 ${result.filesCopied} files`);
+      }
+    }
     await refreshRegistryExports(flintPath);
     console.log();
-    console.log(pc13.dim("Use 'flint export build --all' to build exports."));
+    console.log(pc13.green("Done!"));
     console.log();
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -9311,7 +9867,7 @@ var scanCommand = new Command11("scan").description("Find #export-tagged files n
     process.exit(1);
   }
 });
-var addCommand = new Command11("add").description("Declare a file as an export").argument("<file>", "Source file name (must have #export tag)").argument("<name>", "Export name").argument("[mode]", "Export mode", "mesh").option("-d, --depth <n>", "Export depth (default: 1 for mesh mode)", parseInt).option("-p, --path <dir>", "Path to flint (default: auto-detect)").action(async (file, name, mode, options) => {
+var addCommand = new Command10("add").description("Declare a file as an export").argument("<file>", "Source file name (must have #export tag)").argument("<name>", "Export name").argument("[mode]", "Export mode", "mesh").option("-d, --depth <n>", "Export depth (default: 1 for mesh mode)", parseInt).option("-p, --path <dir>", "Path to flint (default: auto-detect)").action(async (file, name, mode, options) => {
   try {
     const flintPath = options.path || await findFlintRoot(process.cwd());
     if (!flintPath) {
@@ -9357,7 +9913,7 @@ var addCommand = new Command11("add").description("Declare a file as an export")
     process.exit(1);
   }
 });
-var removeCommand = new Command11("remove").description("Remove an export declaration").argument("<name>", "Export name to remove").option("-p, --path <dir>", "Path to flint (default: auto-detect)").action(async (name, options) => {
+var removeCommand = new Command10("remove").description("Remove an export declaration").argument("<name>", "Export name to remove").option("-p, --path <dir>", "Path to flint (default: auto-detect)").action(async (name, options) => {
   try {
     const flintPath = options.path || await findFlintRoot(process.cwd());
     if (!flintPath) {
@@ -9381,7 +9937,7 @@ var removeCommand = new Command11("remove").description("Remove an export declar
     process.exit(1);
   }
 });
-var buildCommand = new Command11("build").description("Build exports").argument("[name]", "Name of export to build (omit for all)").option("-p, --path <dir>", "Path to flint (default: auto-detect)").option("--all", "Build all exports").action(async (name, options) => {
+var buildCommand = new Command10("build").description("Build exports").argument("[name]", "Name of export to build (omit for all)").option("-p, --path <dir>", "Path to flint (default: auto-detect)").option("--all", "Build all exports").action(async (name, options) => {
   try {
     const flintPath = options.path || await findFlintRoot(process.cwd());
     if (!flintPath) {
@@ -9437,7 +9993,7 @@ var buildCommand = new Command11("build").description("Build exports").argument(
     process.exit(1);
   }
 });
-var statusCommand = new Command11("status").description("Show export build status").option("-p, --path <dir>", "Path to flint (default: auto-detect)").action(async (options) => {
+var statusCommand = new Command10("status").description("Show export build status").option("-p, --path <dir>", "Path to flint (default: auto-detect)").action(async (options) => {
   try {
     const flintPath = options.path || await findFlintRoot(process.cwd());
     if (!flintPath) {
@@ -9469,10 +10025,10 @@ var statusCommand = new Command11("status").description("Show export build statu
     process.exit(1);
   }
 });
-var exportCommand = new Command11("export").description("Manage exports").addCommand(listCommand2).addCommand(scanCommand).addCommand(addCommand).addCommand(removeCommand).addCommand(buildCommand).addCommand(statusCommand);
+var exportCommand = new Command10("export").description("Manage exports").addCommand(listCommand2).addCommand(scanCommand).addCommand(addCommand).addCommand(removeCommand).addCommand(buildCommand).addCommand(statusCommand);
 
 // src/commands/import.ts
-import { Command as Command12 } from "commander";
+import { Command as Command11 } from "commander";
 import pc14 from "picocolors";
 import { rm as rm9, stat as stat9 } from "fs/promises";
 import { join as join26, basename as basename5 } from "path";
@@ -9516,7 +10072,7 @@ async function exists4(path3) {
     return false;
   }
 }
-var listCommand3 = new Command12("list").description("List available imports from registered flints").argument("[flint]", "Flint name to show exports from").option("-p, --path <dir>", "Path to flint (default: auto-detect)").action(async (flintName, options) => {
+var listCommand3 = new Command11("list").description("List available imports from registered flints").argument("[flint]", "Flint name to show exports from").option("-p, --path <dir>", "Path to flint (default: auto-detect)").action(async (flintName, options) => {
   try {
     const flintPath = options.path || await findFlintRoot(process.cwd());
     console.log();
@@ -9583,7 +10139,7 @@ var listCommand3 = new Command12("list").description("List available imports fro
     process.exit(1);
   }
 });
-var addCommand2 = new Command12("add").description("Add an import to flint.toml").argument("<ref>", 'Import reference: "<flint>/<export>"').option("-p, --path <dir>", "Path to flint (default: auto-detect)").action(async (ref, options) => {
+var addCommand2 = new Command11("add").description("Add an import to flint.toml").argument("<ref>", 'Import reference: "<flint>/<export>"').option("-p, --path <dir>", "Path to flint (default: auto-detect)").action(async (ref, options) => {
   try {
     const flintPath = options.path || await findFlintRoot(process.cwd());
     if (!flintPath) {
@@ -9651,7 +10207,7 @@ var addCommand2 = new Command12("add").description("Add an import to flint.toml"
     process.exit(1);
   }
 });
-var removeCommand2 = new Command12("remove").description("Remove an import from flint.toml").argument("<ref>", 'Import to remove: "<flint>/<export>"').option("-p, --path <dir>", "Path to flint (default: auto-detect)").option("--delete-files", "Also delete the imported files from Imports/").action(async (ref, options) => {
+var removeCommand2 = new Command11("remove").description("Remove an import from flint.toml").argument("<ref>", 'Import to remove: "<flint>/<export>"').option("-p, --path <dir>", "Path to flint (default: auto-detect)").option("--delete-files", "Also delete the imported files from Imports/").action(async (ref, options) => {
   try {
     const flintPath = options.path || await findFlintRoot(process.cwd());
     if (!flintPath) {
@@ -9694,8 +10250,8 @@ var removeCommand2 = new Command12("remove").description("Remove an import from
       if (deleted) {
         const parentPath = join26(flintPath, "Imports", `(Flint) ${flintName}`);
         try {
-          const { readdir: readdir10 } = await import("fs/promises");
-          const remaining = await readdir10(parentPath);
+          const { readdir: readdir11 } = await import("fs/promises");
+          const remaining = await readdir11(parentPath);
           if (remaining.length === 0) {
             await rm9(parentPath, { recursive: true });
           }
@@ -9710,16 +10266,16 @@ var removeCommand2 = new Command12("remove").description("Remove an import from
     process.exit(1);
   }
 });
-var importCommand = new Command12("import").description("Manage imports from other flints").addCommand(listCommand3).addCommand(addCommand2).addCommand(removeCommand2);
+var importCommand = new Command11("import").description("Manage imports from other flints").addCommand(listCommand3).addCommand(addCommand2).addCommand(removeCommand2);
 
 // src/commands/open.ts
-import { Command as Command13 } from "commander";
-import { exec as exec4 } from "child_process";
+import { Command as Command12 } from "commander";
+import { exec as exec7 } from "child_process";
 import { promisify as promisify8 } from "util";
 import { resolve as resolve9 } from "path";
 import { platform as platform3 } from "os";
 import pc15 from "picocolors";
-var execAsync4 = promisify8(exec4);
+var execAsync7 = promisify8(exec7);
 var APP_NAMES = {
   obsidian: {
     darwin: "Obsidian",
@@ -9747,20 +10303,20 @@ async function openInApp(appId, path3) {
   const appConfig = APP_NAMES[appId.toLowerCase()];
   if (os2 === "darwin") {
     const appName = appConfig?.darwin ?? appId;
-    await execAsync4(`open -a "${appName}" "${path3}"`);
+    await execAsync7(`open -a "${appName}" "${path3}"`);
   } else if (os2 === "win32") {
     const appName = appConfig?.win32 ?? appId;
-    await execAsync4(`start "" "${appName}" "${path3}"`);
+    await execAsync7(`start "" "${appName}" "${path3}"`);
   } else {
     const appName = appConfig?.linux ?? appId.toLowerCase();
     try {
-      await execAsync4(`${appName} "${path3}"`);
+      await execAsync7(`${appName} "${path3}"`);
     } catch {
-      await execAsync4(`xdg-open "${path3}"`);
+      await execAsync7(`xdg-open "${path3}"`);
     }
   }
 }
-var openCommand = new Command13("open").argument("[flint-name]", "Name of the flint to open").description("Open a flint in configured applications").action(async (flintName) => {
+var openCommand = new Command12("open").argument("[flint-name]", "Name of the flint to open").description("Open a flint in configured applications").action(async (flintName) => {
   try {
     let flintPath;
     if (flintName) {
@@ -9817,13 +10373,13 @@ var openCommand = new Command13("open").argument("[flint-name]", "Name of the fl
 });
 
 // src/commands/agent.ts
-import { Command as Command14 } from "commander";
+import { Command as Command13 } from "commander";
 import pc16 from "picocolors";
 import { spawn as spawn4 } from "child_process";
 import { join as join27, dirname as dirname7 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 var __dirname4 = dirname7(fileURLToPath4(import.meta.url));
-var agentCommand = new Command14("agent").description("Manage Flint agents");
+var agentCommand = new Command13("agent").description("Manage Flint agents");
 agentCommand.command("start").description("Start an agent session").option("-p, --path <dir>", "Path to flint mesh (default: auto-detect)").option("-b, --backend <type>", "Agent backend: pydantic | claude-code", "pydantic").option("-m, --model <model>", "Model to use (default: openai/gpt-4o-mini)").option("-g, --goal <goal>", "Initial goal for the agent").option("-s, --skill <skill>", "Skill file to execute").option("--dry-run", "Show what would happen without starting agent").action(async (options) => {
   try {
     const meshPath = options.path || await findFlintRoot(process.cwd());
@@ -10039,7 +10595,7 @@ async function startClaudeCodeAgent(meshPath, options) {
 }
 
 // src/commands/register.ts
-import { Command as Command15 } from "commander";
+import { Command as Command14 } from "commander";
 import pc17 from "picocolors";
 import { createInterface as createInterface3 } from "readline";
 import { resolve as resolve10 } from "path";
@@ -10074,7 +10630,7 @@ async function promptSelect(flints) {
     });
   });
 }
-var registerCommand = new Command15("register").description("Register an existing flint in the global registry").argument("[paths...]", "Paths to flints to register (defaults to current directory)").option("-s, --scan", "Scan for flints in the specified paths (or default locations)").option("-d, --depth <n>", "Max recursion depth for scan (default: 5)", "5").option("--dry-run", "Show what would be registered without doing it").option("-f, --force", "Re-register even if already registered (updates entry)").action(async (pathArgs, options) => {
+var registerCommand = new Command14("register").description("Register an existing flint in the global registry").argument("[paths...]", "Paths to flints to register (defaults to current directory)").option("-s, --scan", "Scan for flints in the specified paths (or default locations)").option("-d, --depth <n>", "Max recursion depth for scan (default: 5)", "5").option("--dry-run", "Show what would be registered without doing it").option("-f, --force", "Re-register even if already registered (updates entry)").action(async (pathArgs, options) => {
   try {
     const depth = parseInt(options.depth, 10) || 5;
     if (options.scan) {
@@ -10199,10 +10755,10 @@ var registerCommand = new Command15("register").description("Register an existin
 });
 
 // src/commands/unregister.ts
-import { Command as Command16 } from "commander";
+import { Command as Command15 } from "commander";
 import pc18 from "picocolors";
 import { resolve as resolve11 } from "path";
-var unregisterCommand = new Command16("unregister").description("Unregister a flint from the global registry").argument("[path]", "Path to the flint (defaults to current directory)").option("-f, --force", "Skip confirmation prompt").action(async (pathArg, options) => {
+var unregisterCommand = new Command15("unregister").description("Unregister a flint from the global registry").argument("[path]", "Path to the flint (defaults to current directory)").option("-f, --force", "Skip confirmation prompt").action(async (pathArg, options) => {
   try {
     let targetPath;
     if (pathArg) {
@@ -10248,9 +10804,9 @@ Flint to unregister:`);
 });
 
 // src/commands/registry.ts
-import { Command as Command17 } from "commander";
+import { Command as Command16 } from "commander";
 import pc19 from "picocolors";
-var validateCommand = new Command17("validate").description("Validate registry and remove broken entries").option("--dry-run", "Check only, do not remove broken entries").option("--json", "Output as JSON").option("-f, --force", "Skip confirmation prompt when removing entries").action(async (options) => {
+var validateCommand = new Command16("validate").description("Validate registry and remove broken entries").option("--dry-run", "Check only, do not remove broken entries").option("--json", "Output as JSON").option("-f, --force", "Skip confirmation prompt when removing entries").action(async (options) => {
   try {
     const cleanResult = await cleanRegistryFile();
     const flintEntries = await getFlintRegistry();
@@ -10352,7 +10908,7 @@ ${pc19.bold("Registry Validation")}
     process.exit(1);
   }
 });
-var tagCommand = new Command17("tag").description("Add a tag to a registered flint").argument("<name>", "Flint name").argument("<tag>", "Tag to add").action(async (name, tag) => {
+var tagCommand = new Command16("tag").description("Add a tag to a registered flint").argument("<name>", "Flint name").argument("<tag>", "Tag to add").action(async (name, tag) => {
   try {
     const flint = await findFlintByName(name);
     if (!flint) {
@@ -10373,7 +10929,7 @@ var tagCommand = new Command17("tag").description("Add a tag to a registered fli
     process.exit(1);
   }
 });
-var untagCommand = new Command17("untag").description("Remove a tag from a registered flint").argument("<name>", "Flint name").argument("<tag>", "Tag to remove").action(async (name, tag) => {
+var untagCommand = new Command16("untag").description("Remove a tag from a registered flint").argument("<name>", "Flint name").argument("<tag>", "Tag to remove").action(async (name, tag) => {
   try {
     const flint = await findFlintByName(name);
     if (!flint) {
@@ -10393,16 +10949,16 @@ var untagCommand = new Command17("untag").description("Remove a tag from a regis
     process.exit(1);
   }
 });
-var registryCommand = new Command17("registry").description("Manage the flint registry").addCommand(validateCommand).addCommand(tagCommand).addCommand(untagCommand);
+var registryCommand = new Command16("registry").description("Manage the flint registry").addCommand(validateCommand).addCommand(tagCommand).addCommand(untagCommand);
 
 // src/commands/obsidian.ts
-import { Command as Command18 } from "commander";
+import { Command as Command17 } from "commander";
 import pc20 from "picocolors";
-import { execSync as execSync6 } from "child_process";
+import { execSync as execSync3, spawnSync } from "child_process";
 import { join as join28 } from "path";
 import { stat as stat10, rm as rm10 } from "fs/promises";
 var OBSIDIAN_REPO_URL2 = "https://github.com/NUU-Cognition/flint-dot-obsidian.git";
-var obsidianCommand = new Command18("obsidian").description("Manage .obsidian configuration").option("-p, --path <dir>", "Path to flint (default: auto-detect)");
+var obsidianCommand = new Command17("obsidian").description("Manage .obsidian configuration").option("-p, --path <dir>", "Path to flint (default: auto-detect)");
 obsidianCommand.command("update").description("Force pull latest .obsidian from remote (discards local changes)").action(async () => {
   const options = obsidianCommand.opts();
   const flintPath = options.path || await findFlintRoot(process.cwd());
@@ -10420,8 +10976,8 @@ obsidianCommand.command("update").description("Force pull latest .obsidian from
   }
   console.log(pc20.dim("Fetching latest from remote..."));
   try {
-    execSync6("git fetch origin", { cwd: obsidianDir, stdio: "pipe" });
-    execSync6("git reset --hard origin/main", { cwd: obsidianDir, stdio: "pipe" });
+    execSync3("git fetch origin", { cwd: obsidianDir, stdio: "pipe" });
+    execSync3("git reset --hard origin/main", { cwd: obsidianDir, stdio: "pipe" });
     console.log(pc20.green("Updated .obsidian to latest from remote."));
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -10446,17 +11002,19 @@ if (isFeatureEnabled(FEATURES, "obsidian.push", resolveRuntimeSync({ cliname: "f
     }
     console.log(pc20.dim("Staging changes..."));
     try {
-      execSync6("git add -A", { cwd: obsidianDir, stdio: "pipe" });
-      const status = execSync6("git status --porcelain", { cwd: obsidianDir, encoding: "utf-8" });
+      execSync3("git add -A", { cwd: obsidianDir, stdio: "pipe" });
+      const status = execSync3("git status --porcelain", { cwd: obsidianDir, encoding: "utf-8" });
       if (!status.trim()) {
         console.log(pc20.yellow("No changes to commit."));
         return;
       }
       console.log(pc20.dim("Committing..."));
-      const safeMessage = cmdOptions.message.replace(/"/g, '\\"');
-      execSync6(`git commit -m "${safeMessage}"`, { cwd: obsidianDir, stdio: "pipe" });
+      const commitResult = spawnSync("git", ["commit", "-m", cmdOptions.message], { cwd: obsidianDir, stdio: "pipe" });
+      if (commitResult.status !== 0) {
+        throw new Error(commitResult.stderr?.toString() || "git commit failed");
+      }
       console.log(pc20.dim("Pushing to remote..."));
-      execSync6("git push origin main", { cwd: obsidianDir, stdio: "pipe" });
+      execSync3("git push origin main", { cwd: obsidianDir, stdio: "pipe" });
       console.log(pc20.green("Pushed .obsidian changes to remote."));
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
@@ -10491,7 +11049,7 @@ obsidianCommand.command("reset").description("Delete and re-clone .obsidian from
       await rm10(obsidianDir, { recursive: true, force: true });
     }
     console.log(pc20.dim("Cloning .obsidian from template repo..."));
-    execSync6(`git clone ${OBSIDIAN_REPO_URL2} "${obsidianDir}"`, { stdio: "pipe" });
+    execSync3(`git clone ${OBSIDIAN_REPO_URL2} "${obsidianDir}"`, { stdio: "pipe" });
     console.log(pc20.green("Reset .obsidian to fresh state from template repo."));
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -10501,10 +11059,10 @@ obsidianCommand.command("reset").description("Delete and re-clone .obsidian from
 });
 
 // src/commands/config.ts
-import { Command as Command19 } from "commander";
+import { Command as Command18 } from "commander";
 import pc21 from "picocolors";
 var CONFIG_PATH = getConfigPath("flint");
-var configCommand = new Command19("config").description("Manage global Flint configuration").argument("[action]", "Action: get, set, or omit to view all").argument("[key]", "Config key (e.g., open.apps)").argument("[value]", "Value to set (JSON for arrays/objects)").action(async (action, key, value) => {
+var configCommand = new Command18("config").description("Manage global Flint configuration").argument("[action]", "Action: get, set, or omit to view all").argument("[key]", "Config key (e.g., open.apps)").argument("[value]", "Value to set (JSON for arrays/objects)").action(async (action, key, value) => {
   try {
     const config = resolveConfigSync({ cliname: "flint" });
     if (!action) {
@@ -10600,10 +11158,10 @@ function getNestedValue(obj, key) {
 }
 
 // src/commands/connection.ts
-import { Command as Command20 } from "commander";
+import { Command as Command19 } from "commander";
 import pc22 from "picocolors";
-var connectionCommand = new Command20("connection").description("Manage connections to other Flints").addCommand(
-  new Command20("add").description("Add a connection to another Flint (must be registered)").argument("<name>", "Name of the registered Flint to connect").option("-p, --path <dir>", "Path to flint (default: auto-detect)").option("--no-fulfill", "Only add declaration, do not auto-fulfill").action(async (targetName, options) => {
+var connectionCommand = new Command19("connection").description("Manage connections to other Flints").addCommand(
+  new Command19("add").description("Add a connection to another Flint (must be registered)").argument("<name>", "Name of the registered Flint to connect").option("-p, --path <dir>", "Path to flint (default: auto-detect)").option("--no-fulfill", "Only add declaration, do not auto-fulfill").action(async (targetName, options) => {
     try {
       const flintPath = options.path || await findFlintRoot(process.cwd());
       if (!flintPath) {
@@ -10631,7 +11189,7 @@ Added connection to ${pc22.bold(status.name)}`));
     }
   })
 ).addCommand(
-  new Command20("remove").description("Remove a connection").argument("<name>", "Name of the connected Flint to remove").option("-p, --path <dir>", "Path to flint (default: auto-detect)").action(async (name, options) => {
+  new Command19("remove").description("Remove a connection").argument("<name>", "Name of the connected Flint to remove").option("-p, --path <dir>", "Path to flint (default: auto-detect)").action(async (name, options) => {
     try {
       const flintPath = options.path || await findFlintRoot(process.cwd());
       if (!flintPath) {
@@ -10657,7 +11215,7 @@ Connection "${name}" not found`));
     }
   })
 ).addCommand(
-  new Command20("list").description("List all connections with status").option("-p, --path <dir>", "Path to flint (default: auto-detect)").action(async (options) => {
+  new Command19("list").description("List all connections with status").option("-p, --path <dir>", "Path to flint (default: auto-detect)").action(async (options) => {
     try {
       const flintPath = options.path || await findFlintRoot(process.cwd());
       if (!flintPath) {
@@ -10707,7 +11265,7 @@ Connection "${name}" not found`));
     }
   })
 ).addCommand(
-  new Command20("fulfill").description("Fulfill a connection by setting its local path").argument("[name]", "Name of the connection to fulfill").option("-p, --path <dir>", "Path to flint (default: auto-detect)").option("--all", "Fulfill all unfulfilled connections interactively").option("--target <path>", "Path to the target Flint (auto-lookup from registry if omitted)").action(async (name, options) => {
+  new Command19("fulfill").description("Fulfill a connection by setting its local path").argument("[name]", "Name of the connection to fulfill").option("-p, --path <dir>", "Path to flint (default: auto-detect)").option("--all", "Fulfill all unfulfilled connections interactively").option("--target <path>", "Path to the target Flint (auto-lookup from registry if omitted)").action(async (name, options) => {
     try {
       const flintPath = options.path || await findFlintRoot(process.cwd());
       if (!flintPath) {
@@ -10769,7 +11327,7 @@ Fulfilled connection to ${pc22.bold(fulfillment.name)}`));
     }
   })
 ).addCommand(
-  new Command20("status").description("Check connection status").option("-p, --path <dir>", "Path to flint (default: auto-detect)").action(async (options) => {
+  new Command19("status").description("Check connection status").option("-p, --path <dir>", "Path to flint (default: auto-detect)").action(async (options) => {
     try {
       const flintPath = options.path || await findFlintRoot(process.cwd());
       if (!flintPath) {
@@ -10817,7 +11375,7 @@ Fulfilled connection to ${pc22.bold(fulfillment.name)}`));
 );
 
 // src/commands/workspace.ts
-import { Command as Command21 } from "commander";
+import { Command as Command20 } from "commander";
 import pc23 from "picocolors";
 import { stat as stat11 } from "fs/promises";
 import * as readline from "readline";
@@ -10841,8 +11399,8 @@ async function pathExists2(path3) {
     return false;
   }
 }
-var workspaceCommand = new Command21("workspace").description("Manage workspace references to external resources").addCommand(
-  new Command21("list").description("List workspace references").option("-p, --path <dir>", "Path to flint (default: auto-detect)").action(async (options) => {
+var workspaceCommand = new Command20("workspace").description("Manage workspace references to external resources").addCommand(
+  new Command20("list").description("List workspace references").option("-p, --path <dir>", "Path to flint (default: auto-detect)").action(async (options) => {
     try {
       const flintPath = options.path || await findFlintRoot(process.cwd());
       if (!flintPath) {
@@ -10889,7 +11447,7 @@ var workspaceCommand = new Command21("workspace").description("Manage workspace
     }
   })
 ).addCommand(
-  new Command21("reference").description("Declare a workspace reference and optionally set its local path").argument("<name>", "Name for this workspace reference").argument("[targetPath]", "Path to the external resource (optional)").option("-t, --type <type>", "Type of reference (codebase, drive, api, database, service)", "codebase").option("-p, --path <dir>", "Path to flint (default: auto-detect)").action(async (name, targetPath, options) => {
+  new Command20("reference").description("Declare a workspace reference and optionally set its local path").argument("<name>", "Name for this workspace reference").argument("[targetPath]", "Path to the external resource (optional)").option("-t, --type <type>", "Type of reference (codebase, drive, api, database, service)", "codebase").option("-p, --path <dir>", "Path to flint (default: auto-detect)").action(async (name, targetPath, options) => {
     try {
       const flintPath = options.path || await findFlintRoot(process.cwd());
       if (!flintPath) {
@@ -10928,7 +11486,7 @@ Declared workspace reference: ${pc23.bold(name)}`));
     }
   })
 ).addCommand(
-  new Command21("fulfill").description("Provide local paths for unfulfilled workspace references").argument("[name]", "Specific reference to fulfill (or all if omitted)").argument("[targetPath]", "Path to the resource (skips prompt if provided)").option("-p, --path <dir>", "Path to flint (default: auto-detect)").action(async (name, targetPath, options) => {
+  new Command20("fulfill").description("Provide local paths for unfulfilled workspace references").argument("[name]", "Specific reference to fulfill (or all if omitted)").argument("[targetPath]", "Path to the resource (skips prompt if provided)").option("-p, --path <dir>", "Path to flint (default: auto-detect)").action(async (name, targetPath, options) => {
     try {
       const flintPath = options.path || await findFlintRoot(process.cwd());
       if (!flintPath) {
@@ -11011,7 +11569,7 @@ Workspace "${name}" is already fulfilled.`));
     }
   })
 ).addCommand(
-  new Command21("remove").description("Remove a workspace reference").argument("<name>", "Name of the workspace reference to remove").option("-p, --path <dir>", "Path to flint (default: auto-detect)").action(async (name, options) => {
+  new Command20("remove").description("Remove a workspace reference").argument("<name>", "Name of the workspace reference to remove").option("-p, --path <dir>", "Path to flint (default: auto-detect)").action(async (name, options) => {
     try {
       const flintPath = options.path || await findFlintRoot(process.cwd());
       if (!flintPath) {
@@ -11039,7 +11597,7 @@ Removed workspace reference: ${pc23.bold(name)}`));
     }
   })
 ).addCommand(
-  new Command21("addrepo").description("Clone a full git repository into Workspace/Repositories/").argument("<name>", "Name for this repository").argument("<url>", "Git URL to clone").option("-p, --path <dir>", "Path to flint (default: auto-detect)").action(async (name, url, options) => {
+  new Command20("addrepo").description("Clone a full git repository into Workspace/Repositories/").argument("<name>", "Name for this repository").argument("<url>", "Git URL to clone").option("-p, --path <dir>", "Path to flint (default: auto-detect)").action(async (name, url, options) => {
     try {
       const flintPath = options.path || await findFlintRoot(process.cwd());
       if (!flintPath) {
@@ -11066,7 +11624,7 @@ Added repository: ${pc23.bold(name)}`));
     }
   })
 ).addCommand(
-  new Command21("createrepo").description("Create a new git repository in Workspace/Repositories/ with a remote origin").argument("<name>", "Name for this repository").argument("<url>", "Git remote URL to set as origin").option("-p, --path <dir>", "Path to flint (default: auto-detect)").action(async (name, url, options) => {
+  new Command20("createrepo").description("Create a new git repository in Workspace/Repositories/ with a remote origin").argument("<name>", "Name for this repository").argument("<url>", "Git remote URL to set as origin").option("-p, --path <dir>", "Path to flint (default: auto-detect)").action(async (name, url, options) => {
     try {
       const flintPath = options.path || await findFlintRoot(process.cwd());
       if (!flintPath) {
@@ -11093,7 +11651,7 @@ Created repository: ${pc23.bold(name)}`));
     }
   })
 ).addCommand(
-  new Command21("removerepo").description("Remove a cloned repository").argument("<name>", "Name of the repository to remove").option("-f, --force", "Skip confirmation prompt").option("-p, --path <dir>", "Path to flint (default: auto-detect)").action(async (name, options) => {
+  new Command20("removerepo").description("Remove a cloned repository").argument("<name>", "Name of the repository to remove").option("-f, --force", "Skip confirmation prompt").option("-p, --path <dir>", "Path to flint (default: auto-detect)").action(async (name, options) => {
     try {
       const flintPath = options.path || await findFlintRoot(process.cwd());
       if (!flintPath) {
@@ -11129,7 +11687,7 @@ Removed repository: ${pc23.bold(name)}`));
     }
   })
 ).addCommand(
-  new Command21("updaterepo").description("Pull latest changes for a repository (or fresh clone with --fresh)").argument("<name>", "Name of the repository to update").option("-p, --path <dir>", "Path to flint (default: auto-detect)").option("--fresh", "Delete and re-clone instead of pulling").action(async (name, options) => {
+  new Command20("updaterepo").description("Pull latest changes for a repository (or fresh clone with --fresh)").argument("<name>", "Name of the repository to update").option("-p, --path <dir>", "Path to flint (default: auto-detect)").option("--fresh", "Delete and re-clone instead of pulling").action(async (name, options) => {
     try {
       const flintPath = options.path || await findFlintRoot(process.cwd());
       if (!flintPath) {
@@ -11160,7 +11718,7 @@ Updated repository: ${pc23.bold(name)}`));
     }
   })
 ).addCommand(
-  new Command21("listrepo").description("List cloned repositories").option("-p, --path <dir>", "Path to flint (default: auto-detect)").action(async (options) => {
+  new Command20("listrepo").description("List cloned repositories").option("-p, --path <dir>", "Path to flint (default: auto-detect)").action(async (options) => {
     try {
       const flintPath = options.path || await findFlintRoot(process.cwd());
       if (!flintPath) {
@@ -11205,7 +11763,7 @@ Updated repository: ${pc23.bold(name)}`));
     }
   })
 ).addCommand(
-  new Command21("addreferencerepo").description("Clone a reference copy of a git repository into Workspace/Sources/Repositories/").argument("<name>", "Name for this source repository").argument("<url>", "Git URL to clone").option("-p, --path <dir>", "Path to flint (default: auto-detect)").action(async (name, url, options) => {
+  new Command20("addreferencerepo").description("Clone a reference copy of a git repository into Workspace/Sources/Repositories/").argument("<name>", "Name for this source repository").argument("<url>", "Git URL to clone").option("-p, --path <dir>", "Path to flint (default: auto-detect)").action(async (name, url, options) => {
     try {
       const flintPath = options.path || await findFlintRoot(process.cwd());
       if (!flintPath) {
@@ -11233,7 +11791,7 @@ Added reference repository: ${pc23.bold(name)}`));
     }
   })
 ).addCommand(
-  new Command21("removereferencerepo").description("Remove a reference repository").argument("<name>", "Name of the reference repository to remove").option("-f, --force", "Skip confirmation prompt").option("-p, --path <dir>", "Path to flint (default: auto-detect)").action(async (name, options) => {
+  new Command20("removereferencerepo").description("Remove a reference repository").argument("<name>", "Name of the reference repository to remove").option("-f, --force", "Skip confirmation prompt").option("-p, --path <dir>", "Path to flint (default: auto-detect)").action(async (name, options) => {
     try {
       const flintPath = options.path || await findFlintRoot(process.cwd());
       if (!flintPath) {
@@ -11269,7 +11827,7 @@ Removed reference repository: ${pc23.bold(name)}`));
     }
   })
 ).addCommand(
-  new Command21("updatereferencerepo").description("Re-fetch a reference repository (delete and re-clone)").argument("<name>", "Name of the reference repository to update").option("-p, --path <dir>", "Path to flint (default: auto-detect)").action(async (name, options) => {
+  new Command20("updatereferencerepo").description("Re-fetch a reference repository (delete and re-clone)").argument("<name>", "Name of the reference repository to update").option("-p, --path <dir>", "Path to flint (default: auto-detect)").action(async (name, options) => {
     try {
       const flintPath = options.path || await findFlintRoot(process.cwd());
       if (!flintPath) {
@@ -11300,7 +11858,7 @@ Updated reference repository: ${pc23.bold(name)}`));
     }
   })
 ).addCommand(
-  new Command21("listreferencerepo").description("List reference repositories").option("-p, --path <dir>", "Path to flint (default: auto-detect)").action(async (options) => {
+  new Command20("listreferencerepo").description("List reference repositories").option("-p, --path <dir>", "Path to flint (default: auto-detect)").action(async (options) => {
     try {
       const flintPath = options.path || await findFlintRoot(process.cwd());
       if (!flintPath) {
@@ -11347,7 +11905,7 @@ Updated reference repository: ${pc23.bold(name)}`));
 );
 
 // src/commands/subflint.ts
-import { Command as Command22 } from "commander";
+import { Command as Command21 } from "commander";
 import pc24 from "picocolors";
 import * as readline2 from "readline";
 import { spawn as spawn5 } from "child_process";
@@ -11393,7 +11951,7 @@ async function resolveParentFlintPath(pathOverride) {
   }
   return getParentFlintPath(detected) ?? detected;
 }
-var subflintCommand = new Command22("subflint").description("Manage subflints (nested unregistered Flints)").argument("[name]", "Subflint name (wrapper mode)").argument("[command...]", "Command to run inside the subflint").option("-p, --path <dir>", "Path to parent flint (default: auto-detect)").allowUnknownOption(true).action(async (name, command, options, commandInstance) => {
+var subflintCommand = new Command21("subflint").description("Manage subflints (nested unregistered Flints)").argument("[name]", "Subflint name (wrapper mode)").argument("[command...]", "Command to run inside the subflint").option("-p, --path <dir>", "Path to parent flint (default: auto-detect)").allowUnknownOption(true).action(async (name, command, options, commandInstance) => {
   if (!name || command.length === 0) {
     commandInstance.help();
     return;
@@ -11435,7 +11993,7 @@ var subflintCommand = new Command22("subflint").description("Manage subflints (n
     process.exit(code ?? 1);
   });
 }).addCommand(
-  new Command22("create").description("Create a new subflint").argument("<name>", "Name of the subflint").option("-p, --path <dir>", "Path to flint (default: auto-detect)").option("--preset <preset>", "Preset to use (e.g., blank, vessel, spec)", "blank").option("-d, --description <desc>", "Description for the subflint").action(async (name, options) => {
+  new Command21("create").description("Create a new subflint").argument("<name>", "Name of the subflint").option("-p, --path <dir>", "Path to flint (default: auto-detect)").option("--preset <preset>", "Preset to use (e.g., blank, vessel, spec)", "blank").option("-d, --description <desc>", "Description for the subflint").action(async (name, options) => {
     try {
       const flintPath = options.path || await findFlintRoot(process.cwd());
       if (!flintPath) {
@@ -11510,7 +12068,7 @@ Subflint created at: ${pc24.cyan(abbreviatePath(entry.path))}`);
     }
   })
 ).addCommand(
-  new Command22("list").description("List all subflints").option("-p, --path <dir>", "Path to flint (default: auto-detect)").action(async (options) => {
+  new Command21("list").description("List all subflints").option("-p, --path <dir>", "Path to flint (default: auto-detect)").action(async (options) => {
     try {
       const flintPath = options.path || await findFlintRoot(process.cwd());
       if (!flintPath) {
@@ -11544,7 +12102,7 @@ Subflint created at: ${pc24.cyan(abbreviatePath(entry.path))}`);
     }
   })
 ).addCommand(
-  new Command22("sync").description("Discover subflints and report status").option("-p, --path <dir>", "Path to flint (default: auto-detect)").action(async (options) => {
+  new Command21("sync").description("Discover subflints and report status").option("-p, --path <dir>", "Path to flint (default: auto-detect)").action(async (options) => {
     try {
       const flintPath = await resolveParentFlintPath(options.path);
       if (!flintPath) {
@@ -11573,7 +12131,7 @@ Discovered ${subflints.length} subflint(s):
     }
   })
 ).addCommand(
-  new Command22("remove").description("Remove a subflint").argument("<name>", "Name of the subflint to remove").option("-p, --path <dir>", "Path to flint (default: auto-detect)").option("-y, --yes", "Skip confirmation").action(async (name, options) => {
+  new Command21("remove").description("Remove a subflint").argument("<name>", "Name of the subflint to remove").option("-p, --path <dir>", "Path to flint (default: auto-detect)").option("-y, --yes", "Skip confirmation").action(async (name, options) => {
     try {
       const flintPath = options.path || await findFlintRoot(process.cwd());
       if (!flintPath) {
@@ -11609,7 +12167,7 @@ Removed subflint ${pc24.bold(removed.name)}`));
     }
   })
 ).addCommand(
-  new Command22("promote").description("Promote a subflint to a registered Flint").argument("<name>", "Name of the subflint to promote").option("-p, --path <dir>", "Path to flint (default: auto-detect)").option("-t, --to <destination>", "Destination path for the promoted Flint").option("-d, --dest <destination>", "Alias for --to").action(async (name, options) => {
+  new Command21("promote").description("Promote a subflint to a registered Flint").argument("<name>", "Name of the subflint to promote").option("-p, --path <dir>", "Path to flint (default: auto-detect)").option("-t, --to <destination>", "Destination path for the promoted Flint").option("-d, --dest <destination>", "Alias for --to").action(async (name, options) => {
     try {
       const flintPath = options.path || await findFlintRoot(process.cwd());
       if (!flintPath) {
@@ -11658,7 +12216,7 @@ Promoted ${pc24.bold(name)} to registered Flint`));
 );
 
 // src/commands/lattice.ts
-import { Command as Command23 } from "commander";
+import { Command as Command22 } from "commander";
 import pc25 from "picocolors";
 
 // ../../packages/lattice/src/paths.ts
@@ -11695,7 +12253,7 @@ function resolveLatticePaths(latticePath, config) {
 }
 
 // ../../packages/lattice/src/config.ts
-import { readFile as readFile10, writeFile as writeFile8, stat as stat12 } from "fs/promises";
+import { readFile as readFile11, writeFile as writeFile8, stat as stat12 } from "fs/promises";
 
 // ../../packages/lattice/src/utils.ts
 function toSlug(name) {
@@ -11716,7 +12274,7 @@ function toMeshFileName(latticeName, exportName, fileName) {
 async function readLatticeToml(latticePath) {
   const configPath = getLatticeConfigPath(latticePath);
   try {
-    const content = await readFile10(configPath, "utf-8");
+    const content = await readFile11(configPath, "utf-8");
     return parse(content);
   } catch (error3) {
     if (error3.code === "ENOENT") {
@@ -11913,7 +12471,7 @@ async function runExport(latticePath, config, exportType) {
 }
 
 // ../../packages/lattice/src/sync.ts
-import { mkdir as mkdir14, stat as stat14, writeFile as writeFile9, rm as rm11, readdir as readdir9, copyFile as copyFile3 } from "fs/promises";
+import { mkdir as mkdir14, stat as stat14, writeFile as writeFile9, rm as rm11, readdir as readdir10, copyFile as copyFile3 } from "fs/promises";
 import { join as join30 } from "path";
 async function fileExists3(path3) {
   try {
@@ -12067,7 +12625,7 @@ async function syncLatticeToMesh(latticePath, meshLatticeBase) {
 async function copyExportsToMesh(sourceDir, targetDir, latticeName, exportName, meshFiles) {
   let entries;
   try {
-    entries = await readdir9(sourceDir, { withFileTypes: true });
+    entries = await readdir10(sourceDir, { withFileTypes: true });
   } catch {
     return;
   }
@@ -12103,8 +12661,8 @@ async function resolveFlintPath(pathOption) {
   }
   return flintPath;
 }
-var latticeCommand = new Command23("lattice").description("Manage lattices configured in flint.toml").option("-p, --path <dir>", "Path to flint (default: auto-detect)").addCommand(
-  new Command23("list").description("List lattices configured in flint.toml").action(async function() {
+var latticeCommand = new Command22("lattice").description("Manage lattices configured in flint.toml").option("-p, --path <dir>", "Path to flint (default: auto-detect)").addCommand(
+  new Command22("list").description("List lattices configured in flint.toml").action(async function() {
     const options = this.parent?.opts();
     const flintPath = await resolveFlintPath(options?.path);
     const config = await readFlintToml(flintPath);
@@ -12120,7 +12678,7 @@ var latticeCommand = new Command23("lattice").description("Manage lattices confi
     }
   })
 ).addCommand(
-  new Command23("sync").description("Sync lattice exports to Mesh/Lattice/").argument("[name]", "Lattice name").option("--all", "Sync all lattices").action(async function(name, options) {
+  new Command22("sync").description("Sync lattice exports to Mesh/Lattice/").argument("[name]", "Lattice name").option("--all", "Sync all lattices").action(async function(name, options) {
     const parentOptions = this.parent?.opts();
     const flintPath = await resolveFlintPath(parentOptions?.path);
     const config = await readFlintToml(flintPath);
@@ -12170,7 +12728,7 @@ var latticeCommand = new Command23("lattice").description("Manage lattices confi
     }
   })
 ).addCommand(
-  new Command23("status").description("Check lattice connection status").argument("[name]", "Lattice name").option("--all", "Check all lattices").action(async function(name, options) {
+  new Command22("status").description("Check lattice connection status").argument("[name]", "Lattice name").option("--all", "Check all lattices").action(async function(name, options) {
     const parentOptions = this.parent?.opts();
     const flintPath = await resolveFlintPath(parentOptions?.path);
     const config = await readFlintToml(flintPath);
@@ -12214,9 +12772,9 @@ var latticeCommand = new Command23("lattice").description("Manage lattices confi
 );
 
 // src/commands/server.ts
-import { Command as Command24 } from "commander";
+import { Command as Command23 } from "commander";
 import pc26 from "picocolors";
-var serverCommand = new Command24("server").description("Manage the local Flint server");
+var serverCommand = new Command23("server").description("Manage the local Flint server");
 serverCommand.command("start").description("Start the Flint server").option("-p, --port <port>", "Port to bind", "7433").option("--host <host>", "Host to bind", "127.0.0.1").action(async (options) => {
   const port = Number(options.port);
   const host = options.host;
@@ -12285,10 +12843,10 @@ serverCommand.command("stop").description("Stop the Flint server").option("--ser
 });
 
 // src/commands/runtime.ts
-import { Command as Command25 } from "commander";
+import { Command as Command24 } from "commander";
 import pc27 from "picocolors";
 import path2 from "path";
-var runtimeCommand = new Command25("runtime").description("Manage Flint runtimes");
+var runtimeCommand = new Command24("runtime").description("Manage Flint runtimes");
 runtimeCommand.command("start [flintPath]").description("Start runtime for a Flint").option("--server <url>", "Server URL", "http://127.0.0.1:7433").action(async (flintPath, options) => {
   const serverUrl = options.server;
   const resolvedPath = flintPath ? path2.resolve(flintPath) : await findFlintRoot(process.cwd());
@@ -12382,41 +12940,69 @@ ${pc27.bold("Active Runtimes")}
 });
 
 // src/commands/code.ts
-import { Command as Command26 } from "commander";
+import { Command as Command25 } from "commander";
 import pc28 from "picocolors";
 import { spawn as spawn7 } from "child_process";
 import { createInterface as createInterface6 } from "readline";
+import { existsSync as existsSync5 } from "fs";
 var CLIENT_INFO = {
   name: "flint_code",
   title: "Flint Code",
   version: "0.1.0"
 };
-async function getCodexThreadId(cwd) {
+async function bootstrapCodexSession(cwd, initPrompt) {
   return new Promise((resolve16, reject) => {
     const proc = spawn7("codex", ["app-server"], {
-      stdio: ["pipe", "pipe", "inherit"],
+      stdio: ["pipe", "pipe", "pipe"],
       cwd
     });
     const rl = createInterface6({ input: proc.stdout });
     const send = (msg) => proc.stdin.write(`${JSON.stringify(msg)}
 `);
-    let msgId = 0;
+    let threadId = null;
+    let sessionPath = null;
     const timeout = setTimeout(() => {
       proc.kill();
-      reject(new Error("Timeout waiting for Codex thread ID"));
+      reject(new Error("Timeout waiting for Codex session"));
     }, 3e4);
+    const cleanup = () => {
+      clearTimeout(timeout);
+      rl.close();
+    };
+    let pollInterval = null;
+    const startPolling = () => {
+      pollInterval = setInterval(() => {
+        if (sessionPath && existsSync5(sessionPath)) {
+          if (pollInterval) clearInterval(pollInterval);
+          send({ method: "turn/interrupt", id: 4, params: { threadId } });
+          setTimeout(() => {
+            cleanup();
+            proc.kill();
+            resolve16(threadId);
+          }, 500);
+        }
+      }, 200);
+    };
     rl.on("line", (line) => {
       try {
         const msg = JSON.parse(line);
         if (msg.id === 2 && msg.result?.thread?.id) {
-          clearTimeout(timeout);
-          rl.close();
-          proc.kill();
-          resolve16(msg.result.thread.id);
+          threadId = msg.result.thread.id;
+          sessionPath = msg.result.thread.path;
+          send({
+            method: "turn/start",
+            id: 3,
+            params: {
+              threadId,
+              input: [{ type: "text", text: initPrompt }]
+            }
+          });
+        }
+        if (msg.id === 3 && msg.result?.turn) {
+          startPolling();
         }
-        if (msg.error && msg.id <= 2) {
-          clearTimeout(timeout);
-          rl.close();
+        if (msg.error && msg.id <= 3) {
+          cleanup();
           proc.kill();
           reject(new Error(msg.error.message));
         }
@@ -12424,19 +13010,15 @@ async function getCodexThreadId(cwd) {
       }
     });
     proc.on("error", (err) => {
-      clearTimeout(timeout);
+      cleanup();
       reject(err);
     });
-    send({ method: "initialize", id: msgId++, params: { clientInfo: CLIENT_INFO } });
+    send({ method: "initialize", id: 0, params: { clientInfo: CLIENT_INFO } });
     send({ method: "initialized", params: {} });
-    send({
-      method: "thread/start",
-      id: 2,
-      params: { cwd }
-    });
+    send({ method: "thread/start", id: 2, params: { cwd } });
   });
 }
-var codeCommand = new Command26("code").description("Launch AI coding agents in the current flint");
+var codeCommand = new Command25("code").description("Launch AI coding agents in the current flint");
 codeCommand.command("claude").description("Open Claude Code TUI").option("-p, --path <dir>", "Path to flint (default: auto-detect)").action(async (options) => {
   try {
     const flintPath = options.path || await findFlintRoot(process.cwd());
@@ -12483,10 +13065,11 @@ codeCommand.command("codex").description("Open Codex TUI with session tracking")
       );
       process.exit(1);
     }
+    const bootstrapPrompt = "init, you are a codex session, please read init-f.md and (System) Flint Init.md";
     console.log(pc28.dim("Starting Codex session..."));
     let threadId;
     try {
-      threadId = await getCodexThreadId(flintPath);
+      threadId = await bootstrapCodexSession(flintPath, bootstrapPrompt);
     } catch (err) {
       if (err.code === "ENOENT") {
         console.error(pc28.red("Error: Codex is not installed."));
@@ -12499,13 +13082,14 @@ codeCommand.command("codex").description("Open Codex TUI with session tracking")
     }
     console.log(pc28.green(`Session ID: ${threadId}`));
     console.log("");
-    const initPrompt = `init, you are a codex session, session id is ${threadId}`;
+    const resumePrompt = `your session id is ${threadId}`;
     const child = spawn7("codex", [
       "resume",
       threadId,
       "-a",
       "never",
-      initPrompt
+      "--full-auto",
+      resumePrompt
     ], {
       cwd: flintPath,
       stdio: "inherit"
@@ -12525,9 +13109,9 @@ codeCommand.command("codex").description("Open Codex TUI with session tracking")
 });
 
 // src/commands/helper.ts
-import { Command as Command27 } from "commander";
+import { Command as Command26 } from "commander";
 import pc29 from "picocolors";
-import { readdirSync, existsSync as existsSync5, statSync } from "fs";
+import { readdirSync, existsSync as existsSync6, statSync } from "fs";
 import { join as join34, basename as basename8 } from "path";
 function extractNumberFromFile(filename, typeName) {
   const regex = new RegExp(`^\\(${typeName}\\)\\s+(\\d+)`, "i");
@@ -12536,7 +13120,7 @@ function extractNumberFromFile(filename, typeName) {
 }
 function collectFilesRecursively(dirPath) {
   const files = [];
-  if (!existsSync5(dirPath)) {
+  if (!existsSync6(dirPath)) {
     return files;
   }
   const entries = readdirSync(dirPath);
@@ -12557,7 +13141,7 @@ function collectFilesRecursively(dirPath) {
 }
 function getNextNumber(flintPath, typeName) {
   const meshDir = join34(flintPath, "Mesh");
-  if (!existsSync5(meshDir)) {
+  if (!existsSync6(meshDir)) {
     return 1;
   }
   const allFiles = collectFilesRecursively(meshDir);
@@ -12570,9 +13154,9 @@ function getNextNumber(flintPath, typeName) {
 function formatNumber(num, padding = 3) {
   return num.toString().padStart(padding, "0");
 }
-var helperCommand = new Command27("helper").description("Helper utilities for Flint workflows").addCommand(
-  new Command27("type").description("Type-specific helpers").addCommand(
-    new Command27("newnumber").description("Get the next available number for a typed artifact").argument("<type>", "Type name (Task, Report, Notepad, Increment, etc.)").option("-p, --path <dir>", "Path to flint (default: auto-detect)").option("--raw", "Output raw number without padding").action(async (typeName, options) => {
+var helperCommand = new Command26("helper").description("Helper utilities for Flint workflows").addCommand(
+  new Command26("type").description("Type-specific helpers").addCommand(
+    new Command26("newnumber").description("Get the next available number for a typed artifact").argument("<type>", "Type name (Task, Report, Notepad, Increment, etc.)").option("-p, --path <dir>", "Path to flint (default: auto-detect)").option("--raw", "Output raw number without padding").action(async (typeName, options) => {
       try {
         const flintPath = options.path || await findFlintRoot(process.cwd());
         if (!flintPath) {
@@ -12595,7 +13179,7 @@ var helperCommand = new Command27("helper").description("Helper utilities for Fl
 );
 
 // src/commands/delete.ts
-import { Command as Command28 } from "commander";
+import { Command as Command27 } from "commander";
 import pc30 from "picocolors";
 import { rm as rm12 } from "fs/promises";
 import { resolve as resolve15 } from "path";
@@ -12612,7 +13196,7 @@ async function prompt4(question) {
     });
   });
 }
-var deleteCommand = new Command28("delete").description("Permanently delete a flint (folder + registry)").argument("[name-or-path]", "Flint name or path (defaults to current directory)").action(async (nameOrPath) => {
+var deleteCommand = new Command27("delete").description("Permanently delete a flint (folder + registry)").argument("[name-or-path]", "Flint name or path (defaults to current directory)").option("-f, --force", "Skip confirmation prompt").action(async (nameOrPath, options) => {
   try {
     let entry;
     if (nameOrPath) {
@@ -12638,18 +13222,20 @@ var deleteCommand = new Command28("delete").description("Permanently delete a fl
         process.exit(1);
       }
     }
-    console.log();
-    console.log(pc30.red(pc30.bold("  This will permanently delete:")));
-    console.log();
-    console.log(`  Name:  ${pc30.bold(entry.name)}`);
-    console.log(`  Path:  ${pc30.cyan(abbreviatePath(entry.path))}`);
-    console.log();
-    const answer = await prompt4(`  Type ${pc30.bold(entry.name)} to confirm: `);
-    if (answer !== entry.name) {
+    if (!options.force) {
       console.log();
-      console.log(pc30.dim("  Cancelled \u2014 name did not match."));
+      console.log(pc30.red(pc30.bold("  This will permanently delete:")));
       console.log();
-      process.exit(0);
+      console.log(`  Name:  ${pc30.bold(entry.name)}`);
+      console.log(`  Path:  ${pc30.cyan(abbreviatePath(entry.path))}`);
+      console.log();
+      const answer = await prompt4(`  Type ${pc30.bold(entry.name)} to confirm: `);
+      if (answer !== entry.name) {
+        console.log();
+        console.log(pc30.dim("  Cancelled \u2014 name did not match."));
+        console.log();
+        process.exit(0);
+      }
     }
     await unregisterFlint(entry.path);
     await rm12(entry.path, { recursive: true });
@@ -12670,7 +13256,7 @@ var featuresCommand = createFeaturesCommand({
 });
 
 // src/commands/org.ts
-import { Command as Command29 } from "commander";
+import { Command as Command28 } from "commander";
 import pc31 from "picocolors";
 var ORGS_CONVEX_URL_PROD = "https://impressive-ptarmigan-132.convex.site";
 var ORGS_CONVEX_URL_DEV = "https://steady-lobster-998.convex.site";
@@ -12703,7 +13289,7 @@ async function requireAuth(env) {
 }
 var runtime = resolveRuntimeSync({ cliname: "flint" });
 var devAvailable = runtime.mode === "dev";
-var orgCommand = new Command29("org").description("Organisation management");
+var orgCommand = new Command28("org").description("Organisation management");
 var registerCmd = orgCommand.command("register").description("Register this flint to an organisation").argument("<slug>", "Organisation slug");
 if (devAvailable) registerCmd.option("--dev", "Use dev environment");
 registerCmd.action(async (slug, options) => {
@@ -12758,7 +13344,7 @@ var newDir = getConfigDir("flint");
 var oldDir = join35(homedir5(), ".flint");
 var intermediateDir = join35(homedir5(), ".nuucognition", ".flint");
 function migrateDir(sourceDir, label) {
-  if (!existsSync6(sourceDir)) return false;
+  if (!existsSync7(sourceDir)) return false;
   try {
     const entries = readdirSync2(sourceDir);
     const filesToMigrate = entries.filter((e) => !e.startsWith(".DS_Store"));
@@ -12768,7 +13354,7 @@ function migrateDir(sourceDir, label) {
     for (const entry of filesToMigrate) {
       const src = join35(sourceDir, entry);
       const dest = join35(newDir, entry);
-      if (!existsSync6(dest)) {
+      if (!existsSync7(dest)) {
         cpSync(src, dest, { recursive: true });
         migrated++;
       }
@@ -12810,7 +13396,7 @@ var authConfig = {
   defaultEnv: devAvailable2 ? "dev" : "prod",
   devAvailable: devAvailable2
 };
-var program = new Command30();
+var program = new Command29();
 program.name("flint").description("Flint cognitive workspace CLI").version(pkg.version).enablePositionalOptions().option("--verbose", "Show stack traces for errors");
 program.addCommand(createLoginCommand(authConfig));
 program.addCommand(createLogoutCommand(authConfig));
@@ -12818,7 +13404,6 @@ program.addCommand(createWhoamiCommand(authConfig));
 var COMMAND_MAP = [
   // Production commands
   { featureId: "init", command: initCommand },
-  { featureId: "clone", command: cloneCommand },
   { featureId: "list", command: listCommand },
   { featureId: "shard", command: shardCommand },
   { featureId: "sync", command: syncCommand },