@nuucognition/flint-cli 0.6.0-dev.6 → 0.6.0-dev.7

package/dist/index.js

@@ -13756,7 +13756,7 @@ var init_installer_DWQPLLKD = __esm({
 // ../../packages/flint/dist/index.js
 var dist_exports = {};
 __export(dist_exports, {
-  DISCOVERY_FILE_PATH: () => DISCOVERY_FILE_PATH,
+  DISCOVERY_DIR: () => DISCOVERY_DIR,
   EntityFrameSchema: () => EntityFrameSchema,
   FLINT_CONFIG_FILENAME: () => FLINT_CONFIG_FILENAME,
   FLINT_JSON_FILENAME: () => FLINT_JSON_FILENAME,
@@ -13824,6 +13824,7 @@ __export(dist_exports, {
   findFlintByName: () => findFlintByName,
   findFlintByPath: () => findFlintByPath,
   findFlintRoot: () => findFlintRoot,
+  findLivePluginForVault: () => findLivePluginForVault,
   findShardEntry: () => findShardEntry,
   findTinderboxRoot: () => findTinderboxRoot,
   findVaultIdByPath: () => findVaultIdByPath,
@@ -13910,6 +13911,7 @@ __export(dist_exports, {
   healShard: () => healShard,
   healTinderbox: () => healTinderbox,
   identity: () => identity2,
+  initEmptyTinderbox: () => initEmptyTinderbox,
   initGit: () => initGit,
   initPlateRepo: () => initPlateRepo,
   installInstalledShard: () => installInstalledShard,
@@ -13960,6 +13962,7 @@ __export(dist_exports, {
   pushWithTags: () => pushWithTags,
   queryArtifacts: () => queryArtifacts,
   queueMigration: () => queueMigration,
+  readAllDiscoveries: () => readAllDiscoveries,
   readArtifactAtPath: () => readArtifactAtPath,
   readConfig: () => readConfig,
   readConfigSync: () => readConfigSync,
@@ -14100,34 +14103,34 @@ import { execFile as execFile7 } from "child_process";
 import { promisify as promisify32 } from "util";
 import { rm as rm32 } from "fs/promises";
 import { execFile as execFile22 } from "child_process";
-import { cp as cp4, mkdir as mkdir82, readdir as readdir42, readFile as readFile52, rename as rename32, rm as rm42, stat as stat52, writeFile as writeFile62 } from "fs/promises";
-import { homedir as homedir22 } from "os";
-import { basename as basename32, dirname as dirname23, join as join92, resolve as resolve32 } from "path";
+import { cp as cp4, mkdir as mkdir92, readdir as readdir52, readFile as readFile72, rename as rename42, rm as rm42, stat as stat52, writeFile as writeFile72 } from "fs/promises";
+import { homedir as homedir4 } from "os";
+import { basename as basename32, dirname as dirname32, join as join112, resolve as resolve42 } from "path";
 import { promisify as promisify52 } from "util";
 import { exec as exec3 } from "child_process";
 import { promisify as promisify42 } from "util";
 import { promises as fs7 } from "fs";
 import path5 from "path";
-import { extname, join as join102 } from "path";
-import { readdir as readdir52, mkdir as mkdir92, readFile as readFile62, rename as rename42, writeFile as writeFile72 } from "fs/promises";
-import { execSync } from "child_process";
-import { parse as parseYaml32 } from "yaml";
-import { spawn as spawn22 } from "child_process";
-import { readdir as readdir62 } from "fs/promises";
-import { join as join112, resolve as resolve42, sep as sep2 } from "path";
-import { readdir as readdir72, rename as rename52, rm as rm52, stat as stat62, mkdir as mkdir10 } from "fs/promises";
-import { basename as basename42, dirname as dirname32, join as join122 } from "path";
-import { readFile as readFile72, writeFile as writeFile82, rename as rename62, mkdir as mkdir11 } from "fs/promises";
+import { readFile as readFile52, writeFile as writeFile62, rename as rename32, mkdir as mkdir82 } from "fs/promises";
 import { existsSync as existsSync3 } from "fs";
-import { dirname as dirname42, join as join132, resolve as resolve5 } from "path";
-import { homedir as homedir32, platform as platform22 } from "os";
+import { dirname as dirname23, join as join92, resolve as resolve32 } from "path";
+import { homedir as homedir22, platform as platform22 } from "os";
 import { randomBytes as randomBytes2 } from "crypto";
-import { readFile as readFile82 } from "fs/promises";
+import { readFile as readFile62, readdir as readdir42, realpath } from "fs/promises";
 import { existsSync as existsSync22 } from "fs";
-import { join as join142 } from "path";
-import { homedir as homedir4 } from "os";
+import { join as join102 } from "path";
+import { homedir as homedir32 } from "os";
 import { request } from "http";
-import { readdir as readdir82, readFile as readFile92, mkdir as mkdir12 } from "fs/promises";
+import { extname, join as join122 } from "path";
+import { readdir as readdir62, mkdir as mkdir10, readFile as readFile82, rename as rename52, writeFile as writeFile82 } from "fs/promises";
+import { execSync } from "child_process";
+import { parse as parseYaml32 } from "yaml";
+import { spawn as spawn22 } from "child_process";
+import { readdir as readdir72 } from "fs/promises";
+import { join as join132, resolve as resolve5, sep as sep2 } from "path";
+import { readdir as readdir82, rename as rename62, rm as rm52, stat as stat62, mkdir as mkdir11 } from "fs/promises";
+import { basename as basename42, dirname as dirname42, join as join142 } from "path";
+import { readdir as readdir92, readFile as readFile92, mkdir as mkdir12 } from "fs/promises";
 import { join as join152, dirname as dirname52, resolve as resolve6, sep as sep22 } from "path";
 import { randomUUID as randomUUID22 } from "crypto";
 import { fileURLToPath as fileURLToPath2 } from "url";
@@ -14135,7 +14138,7 @@ import { stat as stat82 } from "fs/promises";
 import { join as join16 } from "path";
 import path22 from "path";
 import { fileURLToPath as fileURLToPath22 } from "url";
-import { readdir as readdir92, readFile as readFile102, mkdir as mkdir13, writeFile as writeFile9, rm as rm62, stat as stat92, copyFile as copyFile2 } from "fs/promises";
+import { readdir as readdir102, readFile as readFile102, mkdir as mkdir13, writeFile as writeFile9, rm as rm62, stat as stat92, copyFile as copyFile2 } from "fs/promises";
 import { join as join17, basename as basename5, dirname as dirname62, resolve as resolve7, relative as relative3, sep as sep3, extname as extname2 } from "path";
 import { promises as fs42 } from "fs";
 import path52 from "path";
@@ -16604,6 +16607,164 @@ async function resolveReference(root, type, name) {
   const hit = slice.find((f) => f.name.toLowerCase() === normalized);
   return hit ? { path: hit.path, type } : null;
 }
+function getObsidianConfigPath() {
+  const p = platform22();
+  if (p === "darwin") {
+    return join92(homedir22(), "Library", "Application Support", "obsidian", "obsidian.json");
+  }
+  if (p === "win32") {
+    const appData = process.env.APPDATA ?? join92(homedir22(), "AppData", "Roaming");
+    return join92(appData, "obsidian", "obsidian.json");
+  }
+  return join92(homedir22(), ".config", "obsidian", "obsidian.json");
+}
+async function readObsidianConfig(configPath = getObsidianConfigPath()) {
+  if (!existsSync3(configPath)) {
+    return { vaults: {} };
+  }
+  const raw = await readFile52(configPath, "utf-8");
+  const parsed = JSON.parse(raw);
+  return {
+    ...parsed,
+    vaults: parsed.vaults ?? {}
+  };
+}
+async function writeObsidianConfig(config, configPath = getObsidianConfigPath()) {
+  await mkdir82(dirname23(configPath), { recursive: true });
+  if (existsSync3(configPath)) {
+    const current = await readFile52(configPath, "utf-8");
+    await writeFile62(`${configPath}.backup`, current, "utf-8");
+  }
+  const tempPath = `${configPath}.tmp.${process.pid}.${Date.now()}`;
+  await writeFile62(tempPath, JSON.stringify(config), "utf-8");
+  await rename32(tempPath, configPath);
+}
+function findVaultIdByPath(config, absPath) {
+  const target = resolve32(absPath);
+  for (const [id, vault] of Object.entries(config.vaults)) {
+    if (resolve32(vault.path) === target) return id;
+  }
+  return null;
+}
+function generateVaultId() {
+  return randomBytes2(8).toString("hex");
+}
+async function registerVault(absPath, configPath = getObsidianConfigPath()) {
+  const target = resolve32(absPath);
+  const config = await readObsidianConfig(configPath);
+  const existing = findVaultIdByPath(config, target);
+  if (existing) {
+    return { id: existing, alreadyRegistered: true };
+  }
+  const id = generateVaultId();
+  config.vaults[id] = { path: target, ts: Date.now() };
+  await writeObsidianConfig(config, configPath);
+  return { id, alreadyRegistered: false };
+}
+async function readDiscovery(path202) {
+  if (!existsSync22(path202)) return null;
+  try {
+    const raw = await readFile62(path202, "utf-8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.port !== "number" || typeof parsed.pid !== "number") return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function readAllDiscoveries(dir = DISCOVERY_DIR) {
+  let entries;
+  try {
+    entries = await readdir42(dir);
+  } catch {
+    return [];
+  }
+  const records = [];
+  for (const name of entries) {
+    if (!name.endsWith(".json")) continue;
+    const record = await readDiscovery(join102(dir, name));
+    if (record) records.push(record);
+  }
+  return records;
+}
+function isPidAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    if (err.code === "EPERM") return true;
+    return false;
+  }
+}
+async function getLivePlugin(dir = DISCOVERY_DIR) {
+  for (const record of await readAllDiscoveries(dir)) {
+    if (isPidAlive(record.pid)) return record;
+  }
+  return null;
+}
+async function samePath(a, b) {
+  try {
+    return await realpath(a) === await realpath(b);
+  } catch {
+    return a === b;
+  }
+}
+async function findLivePluginForVault(vaultPath, dir = DISCOVERY_DIR) {
+  for (const record of await readAllDiscoveries(dir)) {
+    if (!record.vaultPath) continue;
+    if (!isPidAlive(record.pid)) continue;
+    if (await samePath(record.vaultPath, vaultPath)) return record;
+  }
+  return null;
+}
+async function postOpenVault(port, absPath, timeoutMs = 2e3) {
+  return new Promise((resolvePromise) => {
+    const body = JSON.stringify({ path: absPath });
+    const req = request(
+      {
+        hostname: "127.0.0.1",
+        port,
+        path: "/vault/open",
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Content-Length": Buffer.byteLength(body)
+        },
+        timeout: timeoutMs
+      },
+      (res) => {
+        const chunks = [];
+        res.on("data", (chunk) => chunks.push(chunk));
+        res.on("end", () => {
+          const text = Buffer.concat(chunks).toString("utf-8");
+          try {
+            const parsed = JSON.parse(text);
+            if (parsed.ok === true && typeof parsed.id === "string") {
+              resolvePromise({ ok: true, id: parsed.id, registered: Boolean(parsed.registered) });
+              return;
+            }
+            const errorMessage = typeof parsed.error === "string" ? parsed.error : `unexpected response (status ${res.statusCode ?? "unknown"})`;
+            resolvePromise({ ok: false, error: errorMessage });
+          } catch {
+            resolvePromise({ ok: false, error: `invalid JSON response (status ${res.statusCode ?? "unknown"})` });
+          }
+        });
+        res.on("error", (err) => {
+          resolvePromise({ ok: false, error: err.message });
+        });
+      }
+    );
+    req.on("timeout", () => {
+      req.destroy();
+      resolvePromise({ ok: false, error: `request timed out after ${timeoutMs}ms` });
+    });
+    req.on("error", (err) => {
+      resolvePromise({ ok: false, error: err.message });
+    });
+    req.write(body);
+    req.end();
+  });
+}
 function isRecord3(value) {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
@@ -16620,7 +16781,7 @@ function isDirectionalConnection(value) {
   return "from" in value && "to" in value;
 }
 function getConfigPath2(root) {
-  return join92(root, TINDERBOX_CONFIG_FILENAME);
+  return join112(root, TINDERBOX_CONFIG_FILENAME);
 }
 function getTinderboxFlintMode(declaration) {
   if (declaration.mode) {
@@ -16680,7 +16841,7 @@ function formatTinderboxToml(config) {
 `;
 }
 async function writeTinderboxToml(root, config) {
-  await writeFile62(getConfigPath2(root), formatTinderboxToml(config));
+  await writeFile72(getConfigPath2(root), formatTinderboxToml(config));
 }
 function parseTinderboxToml(content) {
   const parsed = parse2(content);
@@ -16749,7 +16910,7 @@ function parseTinderboxToml(content) {
   };
 }
 async function readTinderboxToml(root) {
-  const content = await readFile52(getConfigPath2(root), "utf-8");
+  const content = await readFile72(getConfigPath2(root), "utf-8");
   const config = parseTinderboxToml(content);
   await validateTinderboxToml(root, config);
   return config;
@@ -16758,12 +16919,9 @@ async function validateTinderboxToml(root, config) {
   if (!config.tinderbox.name.trim()) {
     throw new Error("Invalid tinderbox.toml: [tinderbox].name must be a non-empty string");
   }
-  if (await pathExists32(join92(root, "flint.toml"))) {
+  if (await pathExists32(join112(root, "flint.toml"))) {
     throw new Error("Invalid tinderbox root: the tinderbox root must not also be a Flint");
   }
-  if (!config.flints.required.length) {
-    throw new Error("Invalid tinderbox.toml: [flints].required must contain at least one entry");
-  }
   const names = /* @__PURE__ */ new Set();
   for (const flint of config.flints.required) {
     if (!flint.name.trim()) {
@@ -16830,22 +16988,22 @@ function resolveTinderboxConnections(config) {
   return edges;
 }
 async function findTinderboxRoot(startPath) {
-  let current = resolve32(startPath);
-  const home = resolve32(homedir22());
+  let current = resolve42(startPath);
+  const home = resolve42(homedir4());
   try {
     const currentStat = await stat52(current);
     if (!currentStat.isDirectory()) {
-      current = dirname23(current);
+      current = dirname32(current);
     }
   } catch {
-    current = dirname23(current);
+    current = dirname32(current);
   }
   let currentDevice = (await stat52(current)).dev;
   while (true) {
     if (await pathExists32(getConfigPath2(current))) {
       return current;
     }
-    const parent = dirname23(current);
+    const parent = dirname32(current);
     if (current === parent || current === home) {
       return null;
     }
@@ -16858,13 +17016,13 @@ async function findTinderboxRoot(startPath) {
   }
 }
 async function scanTinderboxFlints(root) {
-  const entries = await readdir42(root, { withFileTypes: true });
+  const entries = await readdir52(root, { withFileTypes: true });
   const flints = [];
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
     if (entry.name.startsWith(".")) continue;
-    const flintPath = join92(root, entry.name);
-    if (!await pathExists32(join92(flintPath, "flint.toml"))) {
+    const flintPath = join112(root, entry.name);
+    if (!await pathExists32(join112(flintPath, "flint.toml"))) {
       continue;
     }
     const config = await readFlintToml(flintPath);
@@ -16894,8 +17052,8 @@ async function reconcileTinderbox(root, config) {
       matched.push({ declaration, actual });
       continue;
     }
-    const expectedPath = join92(root, getTinderboxFolderName(declaration.name));
-    if (await pathExists32(join92(expectedPath, "flint.toml"))) {
+    const expectedPath = join112(root, getTinderboxFolderName(declaration.name));
+    if (await pathExists32(join112(expectedPath, "flint.toml"))) {
       const expectedConfig = await readFlintToml(expectedPath);
       const actualName = expectedConfig?.flint?.name;
       if (actualName && actualName !== declaration.name) {
@@ -16907,7 +17065,7 @@ async function reconcileTinderbox(root, config) {
             folderName: basename32(expectedPath)
           }
         });
-        renamedPaths.add(resolve32(expectedPath));
+        renamedPaths.add(resolve42(expectedPath));
         continue;
       }
     }
@@ -16920,14 +17078,14 @@ async function reconcileTinderbox(root, config) {
     if (ownedNames.has(flint.name)) {
       return false;
     }
-    return !renamedPaths.has(resolve32(flint.path));
+    return !renamedPaths.has(resolve42(flint.path));
   });
   return { matched, undeclared, missing, renamed };
 }
 function buildFlintEntry(path202, name, toml) {
   const entry = {
     name,
-    path: resolve32(path202),
+    path: resolve42(path202),
     source: "local"
   };
   if (toml?.flint.tags?.length) {
@@ -16943,7 +17101,7 @@ async function syncRegistryForFlint(flint) {
   const entry = buildFlintEntry(flint.path, flint.name, toml);
   const byPath = await findFlintByPath(flint.path);
   if (byPath) {
-    if (byPath.name === entry.name && resolve32(byPath.path) === entry.path) {
+    if (byPath.name === entry.name && resolve42(byPath.path) === entry.path) {
       return false;
     }
     await updateFlintEntry(byPath.path, entry);
@@ -16951,7 +17109,7 @@ async function syncRegistryForFlint(flint) {
   }
   const byName = await findFlintByName(flint.name);
   if (byName) {
-    if (resolve32(byName.path) === entry.path) {
+    if (resolve42(byName.path) === entry.path) {
       return false;
     }
     await updateFlintEntry(byName.path, entry);
@@ -16962,11 +17120,11 @@ async function syncRegistryForFlint(flint) {
 }
 async function ensureFlintStructure(flintPath) {
   for (const dir of REQUIRED_FLINT_DIRS) {
-    await mkdir82(join92(flintPath, dir), { recursive: true });
+    await mkdir92(join112(flintPath, dir), { recursive: true });
   }
 }
 async function materializeGitFlint(root, declaration) {
-  const tempPath = join92(root, `.tinderbox-clone-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
+  const tempPath = join112(root, `.tinderbox-clone-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
   try {
     await execFileAsync22("git", ["clone", declaration.source, tempPath]);
     const config = await readFlintToml(tempPath);
@@ -16977,11 +17135,11 @@ async function materializeGitFlint(root, declaration) {
     if (actualName !== declaration.name) {
       throw new Error(`Cloned Flint name "${actualName}" does not match declared name "${declaration.name}"`);
     }
-    const destination = join92(root, getTinderboxFolderName(actualName));
+    const destination = join112(root, getTinderboxFolderName(actualName));
     if (await pathExists32(destination)) {
       throw new Error(`Destination already exists: ${destination}`);
     }
-    await rename32(tempPath, destination);
+    await rename42(tempPath, destination);
     await ensureFlintStructure(destination);
     return {
       name: actualName,
@@ -17012,7 +17170,7 @@ async function resolveDeclaredFlints(root, config, reconciliation) {
           path: actual.path,
           available: true,
           presentInRoot: true,
-          registered: !!registryEntry && resolve32(registryEntry.path) === resolve32(actual.path)
+          registered: !!registryEntry && resolve42(registryEntry.path) === resolve42(actual.path)
         });
         continue;
       }
@@ -17111,7 +17269,7 @@ async function wireTinderboxConnections(config, resolvedFlints) {
       }
       const local = await readReferencesLocal(from.path);
       const existing = local.flints.find((entry) => entry.name.toLowerCase() === edge.to.toLowerCase());
-      const isCurrent = !!existing && resolve32(existing.path) === resolve32(to.path) && await pathExists32(existing.path);
+      const isCurrent = !!existing && resolve42(existing.path) === resolve42(to.path) && await pathExists32(existing.path);
       if (!isCurrent) {
         await upsertFulfillment(from.path, "flints", {
           name: edge.to,
@@ -17132,7 +17290,7 @@ async function wireTinderboxConnections(config, resolvedFlints) {
   }
   return { wired, warnings, errors };
 }
-async function syncTinderbox(root) {
+async function syncTinderbox(root, options3 = {}) {
   const config = await readTinderboxToml(root);
   const initialReconciliation = await reconcileTinderbox(root, config);
   const cloned = [];
@@ -17146,7 +17304,7 @@ async function syncTinderbox(root) {
     try {
       const existingEntry = await findFlintByName(declaration.name);
       if (existingEntry && await pathExists32(existingEntry.path)) {
-        const destination = join92(root, getTinderboxFolderName(declaration.name));
+        const destination = join112(root, getTinderboxFolderName(declaration.name));
         const moveResult = await moveFlint(existingEntry.path, destination);
         moved.push({ name: declaration.name, from: moveResult.from, to: moveResult.to });
         continue;
@@ -17183,6 +17341,55 @@ async function syncTinderbox(root) {
   const wireResult = await wireTinderboxConnections(config, resolved.flints);
   warnings.push(...wireResult.warnings);
   errors.push(...wireResult.errors);
+  const registeredVaults = [];
+  let focusSwitched;
+  if (options3.obsidian !== false) {
+    const obsidianTargets = resolved.flints.filter(
+      (flint) => flint.available && typeof flint.path === "string" && flint.path.length > 0
+    );
+    for (const flint of obsidianTargets) {
+      try {
+        const result = await registerVault(flint.path);
+        registeredVaults.push({
+          name: flint.declaration.name,
+          path: flint.path,
+          id: result.id,
+          alreadyRegistered: result.alreadyRegistered
+        });
+      } catch (error3) {
+        warnings.push({
+          scope: flint.declaration.name,
+          message: `Could not register vault in obsidian.json: ${error3 instanceof Error ? error3.message : String(error3)}`
+        });
+      }
+    }
+    const focusTarget = obsidianTargets[0];
+    if (focusTarget) {
+      try {
+        const plugin = await getLivePlugin();
+        if (plugin) {
+          const response = await postOpenVault(plugin.port, focusTarget.path);
+          if (response.ok) {
+            focusSwitched = {
+              name: focusTarget.declaration.name,
+              path: focusTarget.path,
+              id: response.id
+            };
+          } else {
+            warnings.push({
+              scope: focusTarget.declaration.name,
+              message: `NUU Obsidian plugin focus call failed: ${response.error}`
+            });
+          }
+        }
+      } catch (error3) {
+        warnings.push({
+          scope: focusTarget.declaration.name,
+          message: `NUU Obsidian plugin focus call threw: ${error3 instanceof Error ? error3.message : String(error3)}`
+        });
+      }
+    }
+  }
   return {
     root,
     cloned,
@@ -17192,6 +17399,8 @@ async function syncTinderbox(root) {
     registryUpdated,
     connectionsWired: wireResult.wired,
     undeclared: reconciliation.undeclared,
+    registeredVaults,
+    focusSwitched,
     warnings,
     errors
   };
@@ -17209,7 +17418,7 @@ async function getConnectionDrift(config, resolvedFlints) {
     const local = await readReferencesLocal(from.path);
     const declarationExists = declarations.some((entry) => entry.name.toLowerCase() === edge.to.toLowerCase());
     const fulfillment = local.flints.find((entry) => entry.name.toLowerCase() === edge.to.toLowerCase());
-    const fulfillmentValid = !!fulfillment && resolve32(fulfillment.path) === resolve32(to.path) && await pathExists32(fulfillment.path);
+    const fulfillmentValid = !!fulfillment && resolve42(fulfillment.path) === resolve42(to.path) && await pathExists32(fulfillment.path);
     if (!declarationExists || !fulfillmentValid) {
       drift.push({
         from: edge.from,
@@ -17229,7 +17438,7 @@ async function checkTinderbox(root) {
   const staleRegistry = [];
   for (const flint of discovered) {
     const entry = await findFlintByName(flint.name);
-    if (!entry || resolve32(entry.path) !== resolve32(flint.path)) {
+    if (!entry || resolve42(entry.path) !== resolve42(flint.path)) {
       staleRegistry.push({
         name: flint.name,
         actualPath: flint.path,
@@ -17296,7 +17505,7 @@ async function getTinderboxStatus(root) {
       for (const edge of expectedEdges) {
         const target = resolvedByName.get(edge.to);
         const fulfillment = local.flints.find((entry) => entry.name.toLowerCase() === edge.to.toLowerCase());
-        if (target?.available && target.path && fulfillment && resolve32(fulfillment.path) === resolve32(target.path) && await pathExists32(fulfillment.path)) {
+        if (target?.available && target.path && fulfillment && resolve42(fulfillment.path) === resolve42(target.path) && await pathExists32(fulfillment.path)) {
           connectionsFulfilled++;
         }
       }
@@ -17341,16 +17550,16 @@ async function countFiles(path202) {
   if (!stats.isDirectory()) {
     return 1;
   }
-  const entries = await readdir42(path202, { withFileTypes: true });
+  const entries = await readdir52(path202, { withFileTypes: true });
   let count = 1;
   for (const entry of entries) {
-    count += await countFiles(join92(path202, entry.name));
+    count += await countFiles(join112(path202, entry.name));
   }
   return count;
 }
 async function resolveMoveSource(nameOrPath) {
-  const directPath = resolve32(nameOrPath);
-  if (await pathExists32(join92(directPath, "flint.toml"))) {
+  const directPath = resolve42(nameOrPath);
+  if (await pathExists32(join112(directPath, "flint.toml"))) {
     const config = await readFlintToml(directPath);
     const name = config?.flint?.name;
     if (!name) {
@@ -17362,16 +17571,16 @@ async function resolveMoveSource(nameOrPath) {
   if (!entry) {
     throw new Error(`Flint not found: ${nameOrPath}`);
   }
-  return { path: resolve32(entry.path), name: entry.name };
+  return { path: resolve42(entry.path), name: entry.name };
 }
 async function moveFlint(nameOrPath, destination, options3 = {}) {
   const source = await resolveMoveSource(nameOrPath);
-  const targetPath = resolve32(destination);
-  const targetParent = dirname23(targetPath);
+  const targetPath = resolve42(destination);
+  const targetParent = dirname32(targetPath);
   if (!await pathExists32(targetParent)) {
     throw new Error(`Destination parent does not exist: ${targetParent}`);
   }
-  if (resolve32(source.path) === targetPath) {
+  if (resolve42(source.path) === targetPath) {
     throw new Error(`Destination is the same as source: ${targetPath}`);
   }
   if (await pathExists32(targetPath)) {
@@ -17382,7 +17591,7 @@ async function moveFlint(nameOrPath, destination, options3 = {}) {
   }
   let crossDevice = false;
   try {
-    await rename32(source.path, targetPath);
+    await rename42(source.path, targetPath);
   } catch (error3) {
     const code = error3.code;
     if (code !== "EXDEV") {
@@ -17444,10 +17653,10 @@ async function ensureTinderboxGitRepo(root) {
     }
     initialized = true;
   }
-  const gitignorePath = join92(root, ".gitignore");
+  const gitignorePath = join112(root, ".gitignore");
   let existing = "";
   try {
-    existing = await readFile52(gitignorePath, "utf-8");
+    existing = await readFile72(gitignorePath, "utf-8");
   } catch {
     existing = "";
   }
@@ -17455,13 +17664,41 @@ async function ensureTinderboxGitRepo(root) {
     const block3 = [TINDERBOX_GITIGNORE_HEADER, TINDERBOX_GITIGNORE_PATTERN, ""].join("\n");
     const content = existing ? `${existing.replace(/\n*$/, "\n")}
 ${block3}` : `${block3}`;
-    await writeFile62(gitignorePath, content);
+    await writeFile72(gitignorePath, content);
   }
   return { initialized };
 }
+async function initEmptyTinderbox(parentDir, name) {
+  const trimmedName = name.trim();
+  if (!trimmedName) {
+    throw new Error("Tinderbox name must be non-empty");
+  }
+  const resolvedParent = resolve42(parentDir);
+  if (!await pathExists32(resolvedParent)) {
+    throw new Error(`Parent directory does not exist: ${resolvedParent}`);
+  }
+  if (await pathExists32(join112(resolvedParent, "flint.toml"))) {
+    throw new Error(`Cannot create a Tinderbox inside a Flint: ${resolvedParent}`);
+  }
+  if (await pathExists32(join112(resolvedParent, TINDERBOX_CONFIG_FILENAME))) {
+    throw new Error(`Cannot create a Tinderbox inside a Tinderbox: ${resolvedParent}`);
+  }
+  const tinderboxRoot = join112(resolvedParent, getTinderboxFolderNameForRoot(trimmedName));
+  if (await pathExists32(tinderboxRoot)) {
+    throw new Error(`Destination already exists: ${tinderboxRoot}`);
+  }
+  await mkdir92(tinderboxRoot, { recursive: true });
+  const config = {
+    tinderbox: { name: trimmedName },
+    flints: { required: [] }
+  };
+  await writeTinderboxToml(tinderboxRoot, config);
+  await ensureTinderboxGitRepo(tinderboxRoot);
+  return { root: tinderboxRoot };
+}
 async function startTinderbox(currentFlintPath, name, parentDir) {
-  const flintPath = resolve32(currentFlintPath);
-  if (!await pathExists32(join92(flintPath, "flint.toml"))) {
+  const flintPath = resolve42(currentFlintPath);
+  if (!await pathExists32(join112(flintPath, "flint.toml"))) {
     throw new Error(`Not a Flint: ${flintPath} (missing flint.toml)`);
   }
   const flintToml = await readFlintToml(flintPath);
@@ -17479,22 +17716,22 @@ async function startTinderbox(currentFlintPath, name, parentDir) {
   if (!trimmedName) {
     throw new Error("Tinderbox name must be non-empty");
   }
-  const resolvedParent = resolve32(parentDir ? parentDir : dirname23(flintPath));
+  const resolvedParent = resolve42(parentDir ? parentDir : dirname32(flintPath));
   if (!await pathExists32(resolvedParent)) {
     throw new Error(`Parent directory does not exist: ${resolvedParent}`);
   }
-  if (await pathExists32(join92(resolvedParent, "flint.toml"))) {
+  if (await pathExists32(join112(resolvedParent, "flint.toml"))) {
     throw new Error(`Cannot create a Tinderbox inside a Flint: ${resolvedParent}`);
   }
-  const tinderboxRoot = join92(resolvedParent, getTinderboxFolderNameForRoot(trimmedName));
+  const tinderboxRoot = join112(resolvedParent, getTinderboxFolderNameForRoot(trimmedName));
   if (await pathExists32(tinderboxRoot)) {
     throw new Error(`Destination already exists: ${tinderboxRoot}`);
   }
-  if (await pathExists32(join92(tinderboxRoot, TINDERBOX_CONFIG_FILENAME))) {
+  if (await pathExists32(join112(tinderboxRoot, TINDERBOX_CONFIG_FILENAME))) {
     throw new Error(`tinderbox.toml already exists at ${tinderboxRoot}`);
   }
-  await mkdir82(tinderboxRoot, { recursive: true });
-  const destinationFlint = join92(tinderboxRoot, getTinderboxFolderName(flintName));
+  await mkdir92(tinderboxRoot, { recursive: true });
+  const destinationFlint = join112(tinderboxRoot, getTinderboxFolderName(flintName));
   let move;
   try {
     move = await moveFlint(flintPath, destinationFlint);
@@ -17531,7 +17768,7 @@ async function addFlintToTinderbox(root, flintName) {
   if (!registryEntry || !await pathExists32(registryEntry.path)) {
     throw new Error(`Flint "${flintName}" not found in the global registry`);
   }
-  if (resolve32(registryEntry.path).startsWith(`${resolve32(root)}/`) || resolve32(registryEntry.path) === resolve32(root)) {
+  if (resolve42(registryEntry.path).startsWith(`${resolve42(root)}/`) || resolve42(registryEntry.path) === resolve42(root)) {
     throw new Error(`Flint "${flintName}" already lives inside this Tinderbox`);
   }
   const remote = await readGitRemoteUrl(registryEntry.path);
@@ -17540,7 +17777,7 @@ async function addFlintToTinderbox(root, flintName) {
       `Flint "${flintName}" has no git remote. Configure one with \`git remote add origin <url>\` before adding to a Tinderbox.`
     );
   }
-  const destination = join92(root, getTinderboxFolderName(flintName));
+  const destination = join112(root, getTinderboxFolderName(flintName));
   if (await pathExists32(destination)) {
     throw new Error(`Destination already exists: ${destination}`);
   }
@@ -17652,9 +17889,9 @@ async function installDependency(flintPath, source, version) {
 }
 async function healShardScaffolding(folderPath, name) {
   for (const sub of SHARD_SPEC_DIRS_SOURCE) {
-    await mkdir92(join102(folderPath, sub), { recursive: true });
+    await mkdir10(join122(folderPath, sub), { recursive: true });
   }
-  const yamlPath = join102(folderPath, "shard.yaml");
+  const yamlPath = join122(folderPath, "shard.yaml");
   if (!await exists2(yamlPath)) {
     const stub = `shard-spec: "0.2.0"
 version: "0.1.0"
@@ -17662,20 +17899,20 @@ name: ${name}
 shorthand: ${name}
 description: ""
 `;
-    await writeFile72(yamlPath, stub, "utf-8");
+    await writeFile82(yamlPath, stub, "utf-8");
   }
-  const readmePath = join102(folderPath, "README.md");
+  const readmePath = join122(folderPath, "README.md");
   if (!await exists2(readmePath)) {
-    await writeFile72(readmePath, `# ${name}
+    await writeFile82(readmePath, `# ${name}
 `, "utf-8");
   }
-  const releasePath = join102(folderPath, "RELEASE.md");
+  const releasePath = join122(folderPath, "RELEASE.md");
   if (!await exists2(releasePath)) {
-    await writeFile72(releasePath, "# 0.1.0\n\n- Initial shard scaffold\n", "utf-8");
+    await writeFile82(releasePath, "# 0.1.0\n\n- Initial shard scaffold\n", "utf-8");
   }
-  const migrationsPath = join102(folderPath, "MIGRATIONS.md");
+  const migrationsPath = join122(folderPath, "MIGRATIONS.md");
   if (!await exists2(migrationsPath)) {
-    await writeFile72(
+    await writeFile82(
       migrationsPath,
       `# Migrations
 
@@ -17714,7 +17951,7 @@ function filterManifestHealthErrors(manifest, errors) {
 }
 async function resolveExistingSystemFolder(flintPath, folder) {
   for (const candidate of [folder.canonical, ...folder.alternates]) {
-    if (await exists2(join102(flintPath, candidate))) {
+    if (await exists2(join122(flintPath, candidate))) {
       return candidate;
     }
   }
@@ -17744,7 +17981,7 @@ function hasReadonlyTag(content) {
 }
 async function readGitignore(flintPath) {
   try {
-    return await readFile62(join102(flintPath, ".gitignore"), "utf-8");
+    return await readFile82(join122(flintPath, ".gitignore"), "utf-8");
   } catch {
     return "";
   }
@@ -17765,13 +18002,13 @@ function declarationMatchesFolder(flintPath, declarationName, declaration, folde
     if (relativePath.startsWith("./")) {
       relativePath = relativePath.slice(2);
     }
-    return join102(flintPath, relativePath) === join102(flintPath, "Shards", folderName);
+    return join122(flintPath, relativePath) === join122(flintPath, "Shards", folderName);
   }
   return false;
 }
 async function countFiles2(dirPath) {
   try {
-    const entries = await readdir52(dirPath, { withFileTypes: true });
+    const entries = await readdir62(dirPath, { withFileTypes: true });
     return entries.filter((e) => e.isFile() && e.name.endsWith(".md")).length;
   } catch {
     return 0;
@@ -17789,12 +18026,12 @@ function stripShardFolderPrefix(folderName) {
 function buildRenameAction(shardPath, currentRelativePath, nextRelativePath) {
   return {
     action: async () => {
-      const currentPath = join102(shardPath, currentRelativePath);
-      const nextPath = join102(shardPath, nextRelativePath);
+      const currentPath = join122(shardPath, currentRelativePath);
+      const nextPath = join122(shardPath, nextRelativePath);
       if (await exists2(nextPath)) {
         throw new Error(`Cannot rename ${currentRelativePath} to ${nextRelativePath}: destination already exists`);
       }
-      await rename42(currentPath, nextPath);
+      await rename52(currentPath, nextPath);
     },
     actionLabel: `Rename to ${nextRelativePath}`
   };
@@ -17976,10 +18213,10 @@ async function collectMarkdownBasenames(dirPath) {
     return basenames;
   }
   const visit = async (currentPath) => {
-    const entries = await readdir52(currentPath, { withFileTypes: true });
+    const entries = await readdir62(currentPath, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.name.startsWith(".")) continue;
-      const entryPath = join102(currentPath, entry.name);
+      const entryPath = join122(currentPath, entry.name);
       if (entry.isDirectory()) {
         await visit(entryPath);
         continue;
@@ -17998,11 +18235,11 @@ async function collectMarkdownRelativePaths(dirPath) {
     return relativePaths;
   }
   const visit = async (currentPath, prefix = "") => {
-    const entries = await readdir52(currentPath, { withFileTypes: true });
+    const entries = await readdir62(currentPath, { withFileTypes: true });
     for (const entry of entries) {
       if (entry.name.startsWith(".")) continue;
       const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
-      const entryPath = join102(currentPath, entry.name);
+      const entryPath = join122(currentPath, entry.name);
       if (entry.isDirectory()) {
         await visit(entryPath, relativePath);
         continue;
@@ -18026,9 +18263,9 @@ function pushMissingReferences(results, check, references, existingFiles, label)
 }
 async function validateInitContent(shardPath, shorthand) {
   const relativePath = `init-${shorthand}.md`;
-  const filePath = join102(shardPath, relativePath);
+  const filePath = join122(shardPath, relativePath);
   if (!await exists2(filePath)) return [];
-  const content = await readFile62(filePath, "utf-8");
+  const content = await readFile82(filePath, "utf-8");
   const sections = parseMarkdownSections(content);
   const results = [];
   const intro = sections[0]?.body ?? "";
@@ -18061,7 +18298,7 @@ async function validateInitContent(shardPath, shorthand) {
       );
     }
     const references = getReferencedFiles(section3.body, spec.regex);
-    const existingFiles = await collectMarkdownBasenames(join102(shardPath, spec.dir));
+    const existingFiles = await collectMarkdownBasenames(join122(shardPath, spec.dir));
     pushMissingReferences(results, relativePath, references, existingFiles, `Init ${spec.label} section`);
   }
   if (!findSection(sections, /\brequired reading\b/i)) {
@@ -18074,9 +18311,9 @@ async function validateInitContent(shardPath, shorthand) {
 }
 async function validateHeadlessInitContent(shardPath, shorthand) {
   const relativePath = `hinit-${shorthand}.md`;
-  const filePath = join102(shardPath, relativePath);
+  const filePath = join122(shardPath, relativePath);
   if (!await exists2(filePath)) return [];
-  const content = await readFile62(filePath, "utf-8");
+  const content = await readFile82(filePath, "utf-8");
   const sections = parseMarkdownSections(content);
   const results = [];
   const workflowsSection = findSection(sections, /\bheadless workflows\b/i);
@@ -18089,7 +18326,7 @@ async function validateHeadlessInitContent(shardPath, shorthand) {
       );
     }
     const references = getReferencedFiles(workflowsSection.body, WORKFLOW_REFERENCE_REGEX);
-    const existingFiles = await collectMarkdownBasenames(join102(shardPath, "workflows"));
+    const existingFiles = await collectMarkdownBasenames(join122(shardPath, "workflows"));
     pushMissingReferences(results, relativePath, references, existingFiles, "Headless Workflows section");
     if (!references.some((reference) => reference.startsWith("hwkfl-")) || !/replaces/i.test(workflowsSection.body)) {
       results.push(
@@ -18123,10 +18360,10 @@ async function validateHeadlessInitContent(shardPath, shorthand) {
 }
 async function validateTemplateContent(shardPath) {
   const results = [];
-  const files = await collectMarkdownRelativePaths(join102(shardPath, "templates"));
+  const files = await collectMarkdownRelativePaths(join122(shardPath, "templates"));
   for (const relativeFile of files) {
     const relativePath = `templates/${relativeFile}`;
-    const content = await readFile62(join102(shardPath, relativePath), "utf-8");
+    const content = await readFile82(join122(shardPath, relativePath), "utf-8");
     if (!MARKDOWN_FILENAME_LINE_REGEX.test(content)) {
       results.push(
         createContentWarning(relativePath, 'Template should declare its output filename with a "# File:" header')
@@ -18156,10 +18393,10 @@ async function validateTemplateContent(shardPath) {
 }
 async function validateSkillContent(shardPath) {
   const results = [];
-  const files = await collectMarkdownRelativePaths(join102(shardPath, "skills"));
+  const files = await collectMarkdownRelativePaths(join122(shardPath, "skills"));
   for (const relativeFile of files) {
     const relativePath = `skills/${relativeFile}`;
-    const content = await readFile62(join102(shardPath, relativePath), "utf-8");
+    const content = await readFile82(join122(shardPath, relativePath), "utf-8");
     const sections = parseMarkdownSections(content);
     if (!findSection(sections, /\binput\b/i)) {
       results.push(createContentWarning(relativePath, "Skill is missing an Input section"));
@@ -18178,10 +18415,10 @@ async function validateSkillContent(shardPath) {
 }
 async function validateWorkflowContent(shardPath) {
   const results = [];
-  const files = await collectMarkdownRelativePaths(join102(shardPath, "workflows"));
+  const files = await collectMarkdownRelativePaths(join122(shardPath, "workflows"));
   for (const relativeFile of files) {
     const relativePath = `workflows/${relativeFile}`;
-    const content = await readFile62(join102(shardPath, relativePath), "utf-8");
+    const content = await readFile82(join122(shardPath, relativePath), "utf-8");
     const sections = parseMarkdownSections(content);
     const isHeadless = relativeFile.split("/").pop()?.startsWith("hwkfl-") ?? false;
     if (!findSection(sections, /\binput\b/i)) {
@@ -18227,10 +18464,10 @@ async function validateWorkflowContent(shardPath) {
 }
 async function validateKnowledgeContent(shardPath) {
   const results = [];
-  const files = await collectMarkdownRelativePaths(join102(shardPath, "knowledge"));
+  const files = await collectMarkdownRelativePaths(join122(shardPath, "knowledge"));
   for (const relativeFile of files) {
     const relativePath = `knowledge/${relativeFile}`;
-    const content = await readFile62(join102(shardPath, relativePath), "utf-8");
+    const content = await readFile82(join122(shardPath, relativePath), "utf-8");
     const sections = parseMarkdownSections(content);
     const lineCount = content.split(/\r?\n/).length;
     if (!sections[0]?.heading) {
@@ -18265,7 +18502,7 @@ async function validateTypeDefinitions(shardPath, shorthand, manifest) {
     }
     const expectedSource = resolveTypeSourceFilename(typeDecl, shorthand);
     const expectedDest = resolveTypeDestPath(typeDecl, manifest.name);
-    const sourceExists = await exists2(join102(shardPath, "install", expectedSource));
+    const sourceExists = await exists2(join122(shardPath, "install", expectedSource));
     if (!sourceExists) {
       results.push(
         createContentWarning(
@@ -18275,7 +18512,7 @@ async function validateTypeDefinitions(shardPath, shorthand, manifest) {
       );
     } else {
       try {
-        const content = await readFile62(join102(shardPath, "install", expectedSource), "utf-8");
+        const content = await readFile82(join122(shardPath, "install", expectedSource), "utf-8");
         const sections = parseMarkdownSections(content);
         const headings = new Set(sections.map((s) => s.heading));
         for (const property of TYPE_DEFINITION_PROPERTIES) {
@@ -18309,9 +18546,9 @@ async function validateTypeDefinitions(shardPath, shorthand, manifest) {
 }
 async function validateReleaseChangelog(shardPath) {
   const relativePath = "RELEASE.md";
-  const filePath = join102(shardPath, relativePath);
+  const filePath = join122(shardPath, relativePath);
   if (!await exists2(filePath)) return [];
-  const content = await readFile62(filePath, "utf-8");
+  const content = await readFile82(filePath, "utf-8");
   const results = [];
   const entries = content.split(/\n\s*---\s*\n/g).map((entry) => entry.trim()).filter((entry) => entry.length > 0);
   if (entries.length === 0) {
@@ -18344,20 +18581,20 @@ async function validateRuntimeEnvironment(shardPath, folderName, manifest) {
   if (!manifest) return [];
   const results = [];
   const capabilityParts = [];
-  const scriptsDir = join102(shardPath, "scripts");
-  const workspaceReqsDir = join102(shardPath, "workspace-reqs");
-  const yamlPath = join102(shardPath, "shard.yaml");
+  const scriptsDir = join122(shardPath, "scripts");
+  const workspaceReqsDir = join122(shardPath, "workspace-reqs");
+  const yamlPath = join122(shardPath, "shard.yaml");
   try {
-    const yamlContent = await readFile62(yamlPath, "utf-8");
+    const yamlContent = await readFile82(yamlPath, "utf-8");
     if (/^scripts\s*:/m.test(yamlContent)) {
       results.push(withCategory({
         check: "shard.yaml/scripts",
         status: "warning",
         message: "scripts: field is deprecated \u2014 scripts are auto-discovered from scripts/*.js",
         action: async () => {
-          const content = await readFile62(yamlPath, "utf-8");
+          const content = await readFile82(yamlPath, "utf-8");
           const cleaned = content.replace(/^scripts\s*:.*(?:\n(?:[ \t]+.*))*\n?/m, "");
-          await writeFile72(yamlPath, cleaned);
+          await writeFile82(yamlPath, cleaned);
         },
         actionLabel: "Drop scripts: field \u2014 scripts are auto-discovered from scripts/*.js"
       }, "Runtime", folderName));
@@ -18366,7 +18603,7 @@ async function validateRuntimeEnvironment(shardPath, folderName, manifest) {
   }
   const discoveredScripts = [];
   try {
-    const entries = await readdir52(scriptsDir, { withFileTypes: true });
+    const entries = await readdir62(scriptsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isFile() || !entry.name.endsWith(".js")) continue;
       discoveredScripts.push(entry.name.slice(0, -3));
@@ -18392,7 +18629,7 @@ async function validateRuntimeEnvironment(shardPath, folderName, manifest) {
       `Workspace: ${workspaceRequirements.map((requirement) => requirement.name).join(", ")}`
     );
     for (const requirement of workspaceRequirements) {
-      const requirementPath = join102(shardPath, requirement.source);
+      const requirementPath = join122(shardPath, requirement.source);
       if (!await exists2(requirementPath)) {
         results.push(withCategory(
           createContentWarning(
@@ -18405,7 +18642,7 @@ async function validateRuntimeEnvironment(shardPath, folderName, manifest) {
       }
     }
   } else if (await exists2(workspaceReqsDir)) {
-    const entries = await readdir52(workspaceReqsDir, { withFileTypes: true });
+    const entries = await readdir62(workspaceReqsDir, { withFileTypes: true });
     if (entries.some((entry) => entry.isFile() && entry.name.endsWith(".js"))) {
       results.push(withCategory(
         createContentWarning(
@@ -18457,7 +18694,7 @@ async function validateShardStateModel(flintPath, folderName, manifest) {
       }, "State", folderName));
       return;
     }
-    const content = await readFile62(filePath, "utf-8");
+    const content = await readFile82(filePath, "utf-8");
     const parsed = parseFrontmatterRecord(content);
     if (!parsed) {
       results.push(withHealthMeta({
@@ -18493,11 +18730,11 @@ async function validateShardStateModel(flintPath, folderName, manifest) {
   if (requiresShardState) {
     const stateFolder = await resolveExistingSystemFolder(flintPath, SHARD_SYSTEM_FOLDERS[1]) ?? SHARD_SYSTEM_FOLDERS[1].canonical;
     const relativePath = `${stateFolder}/(Shard) ${manifest.name}.md`;
-    await validateStateFile(join102(flintPath, relativePath), relativePath);
+    await validateStateFile(join122(flintPath, relativePath), relativePath);
   }
   if (requiresLocalState) {
     const relativePath = `${SHARD_SYSTEM_FOLDERS[2].canonical}/(Shard) ${manifest.name} (Local).md`;
-    await validateStateFile(join102(flintPath, relativePath), relativePath);
+    await validateStateFile(join122(flintPath, relativePath), relativePath);
   }
   return results;
 }
@@ -18537,7 +18774,7 @@ async function collectShardStructureResults(shardPath, shorthand, shardName = sh
   const migrationPattern = new RegExp(`^mig-${escapedShorthand}-\\d+\\.\\d+\\.\\d+-to-\\d+\\.\\d+\\.\\d+\\.(?:md|js|mjs)$`);
   const devMigrationPattern = new RegExp(`^dev-mig-${escapedShorthand}-\\d+\\.\\d+\\.\\d+-to-\\d+\\.\\d+\\.\\d+\\.(?:md|js|mjs)$`);
   const expectedInitName = isDev ? `dev-init-${shorthand}.md` : `init-${shorthand}.md`;
-  if (!await exists2(join102(shardPath, expectedInitName))) {
+  if (!await exists2(join122(shardPath, expectedInitName))) {
     results.push({
       check: expectedInitName,
       status: "warning",
@@ -18580,7 +18817,7 @@ async function collectShardStructureResults(shardPath, shorthand, shardName = sh
     };
   };
   try {
-    const rootEntries = await readdir52(shardPath, { withFileTypes: true });
+    const rootEntries = await readdir62(shardPath, { withFileTypes: true });
     const allowedRootDirs = /* @__PURE__ */ new Set([...SHARD_SPEC_DIRS_SOURCE, ...OPTIONAL_SHARD_ROOT_DIRS]);
     for (const entry of rootEntries) {
       if (entry.name.startsWith(".")) continue;
@@ -18609,10 +18846,10 @@ async function collectShardStructureResults(shardPath, shorthand, shardName = sh
     return results;
   }
   const inspectDir = async (dir, validateFile) => {
-    const dirPath = join102(shardPath, dir);
+    const dirPath = join122(shardPath, dir);
     if (!await exists2(dirPath)) return;
     const visit = async (currentPath, relativePrefix = "") => {
-      const entries = await readdir52(currentPath, { withFileTypes: true });
+      const entries = await readdir62(currentPath, { withFileTypes: true });
       for (const entry of entries) {
         if (entry.name.startsWith(".")) continue;
         const relativeName = relativePrefix ? `${relativePrefix}/${entry.name}` : entry.name;
@@ -18626,7 +18863,7 @@ async function collectShardStructureResults(shardPath, shorthand, shardName = sh
             });
             continue;
           }
-          await visit(join102(currentPath, entry.name), relativeName);
+          await visit(join122(currentPath, entry.name), relativeName);
           continue;
         }
         const issue = validateFile(shardRelativePath, entry.name);
@@ -18809,7 +19046,7 @@ async function checkShardHealth(flintPath, identifier) {
   const snapshotManifests = /* @__PURE__ */ new Map();
   const blockingManifestFolders = /* @__PURE__ */ new Set();
   for (const folder of targetFolders) {
-    const shardPath = join102(flintPath, "Shards", folder);
+    const shardPath = join122(flintPath, "Shards", folder);
     const strictResult = await readShardManifest(shardPath);
     const snapshot = await readShardManifestSnapshot(shardPath);
     manifestResults.set(folder, strictResult);
@@ -18843,7 +19080,7 @@ async function checkShardHealth(flintPath, identifier) {
         status: "warning",
         message: "Missing shard system folder",
         action: async () => {
-          await mkdir92(join102(flintPath, folder.canonical), { recursive: true });
+          await mkdir10(join122(flintPath, folder.canonical), { recursive: true });
         },
         actionLabel: `Create ${folder.canonical}`
       }, "State"));
@@ -18860,7 +19097,7 @@ async function checkShardHealth(flintPath, identifier) {
   for (const folder of targetFolders) {
     const kebab = toKebabCase3(folder);
     if (!declaredKebabNames.has(kebab)) {
-      const shardPath = join102(flintPath, "Shards", folder);
+      const shardPath = join122(flintPath, "Shards", folder);
       const manifestResult = manifestResults.get(folder) ?? await readShardManifest(shardPath);
       const manifest = manifests.get(folder);
       if (manifest) {
@@ -18898,7 +19135,7 @@ async function checkShardHealth(flintPath, identifier) {
     }
     if (decl.source.startsWith("path:")) {
       const relativePath = decl.source.slice(5);
-      const fullPath = join102(flintPath, relativePath);
+      const fullPath = join122(flintPath, relativePath);
       if (!await exists2(fullPath)) {
         results.push(withHealthMeta({
           check: `${name} (${decl.source})`,
@@ -18913,7 +19150,7 @@ async function checkShardHealth(flintPath, identifier) {
     }
   }
   for (const folder of targetFolders) {
-    const shardPath = join102(flintPath, "Shards", folder);
+    const shardPath = join122(flintPath, "Shards", folder);
     const manifestResult = manifestResults.get(folder) ?? await readShardManifest(shardPath);
     const manifest = manifests.get(folder);
     if (!manifestResult) {
@@ -18931,7 +19168,7 @@ name: ${name}
 shorthand: ${shorthand}
 description: ${name} shard
 `;
-          await writeFile72(join102(shardPath, "shard.yaml"), yaml);
+          await writeFile82(join122(shardPath, "shard.yaml"), yaml);
         },
         actionLabel: `Create minimal shard.yaml for ${folder}`
       }, "Manifest", folder));
@@ -18955,7 +19192,7 @@ description: ${name} shard
   }
   for (const folder of targetFolders) {
     if (blockingManifestFolders.has(folder)) continue;
-    const shardPath = join102(flintPath, "Shards", folder);
+    const shardPath = join122(flintPath, "Shards", folder);
     const manifest = manifests.get(folder) ?? null;
     if (!manifest) continue;
     const kebab = toKebabCase3(folder);
@@ -18963,14 +19200,14 @@ description: ${name} shard
     const mode = decl ? decl.kind : folder.startsWith("(Dev Remote)") || folder.startsWith("(Dev)") ? "dev-remote" : folder.startsWith("(Dev Local)") || folder.startsWith("(Local)") ? "dev-local" : "installed";
     const expectedDirs = mode === "installed" ? SHARD_SPEC_DIRS_INSTALLED : SHARD_SPEC_DIRS_SOURCE;
     for (const dir of expectedDirs) {
-      const dirPath = join102(shardPath, dir);
+      const dirPath = join122(shardPath, dir);
       if (!await exists2(dirPath)) {
         results.push(withHealthMeta({
           check: `Shards/${folder}/${dir}/`,
           status: "warning",
           message: "Missing shard-spec directory",
           action: async () => {
-            await mkdir92(dirPath, { recursive: true });
+            await mkdir10(dirPath, { recursive: true });
           },
           actionLabel: `Create ${dir}/ in ${folder}`
         }, "Structure", folder));
@@ -18979,7 +19216,7 @@ description: ${name} shard
   }
   for (const folder of targetFolders) {
     if (blockingManifestFolders.has(folder)) continue;
-    const shardPath = join102(flintPath, "Shards", folder);
+    const shardPath = join122(flintPath, "Shards", folder);
     const manifest = manifests.get(folder) ?? null;
     if (!manifest) continue;
     const shardName = manifest.name;
@@ -18999,16 +19236,16 @@ description: ${name} shard
   }
   for (const folder of targetFolders) {
     if (blockingManifestFolders.has(folder)) continue;
-    const shardPath = join102(flintPath, "Shards", folder);
+    const shardPath = join122(flintPath, "Shards", folder);
     const manifest = manifests.get(folder) ?? null;
     if (!manifest?.install?.length) continue;
     const folderEntry = findShardEntry(config, toKebabCase3(folder));
     const mode = folderEntry ? folderEntry.kind : folder.startsWith("(Dev Remote)") || folder.startsWith("(Dev)") ? "dev-remote" : folder.startsWith("(Dev Local)") || folder.startsWith("(Local)") ? "dev-local" : "installed";
     if (mode !== "installed") continue;
     for (const entry of manifest.install) {
-      const installedPath = join102(flintPath, entry.dest);
+      const installedPath = join122(flintPath, entry.dest);
       if (!await exists2(installedPath)) continue;
-      const content = await readFile62(installedPath, "utf-8");
+      const content = await readFile82(installedPath, "utf-8");
       if (!hasReadonlyTag(content)) {
         results.push(withHealthMeta({
           check: entry.dest,
@@ -19080,7 +19317,7 @@ async function healShard(flintPath, folderName) {
     );
   }
   const results = [];
-  const shardPath = join102(flintPath, "Shards", folderName);
+  const shardPath = join122(flintPath, "Shards", folderName);
   const kebab = toKebabCase3(folderName);
   const manifestResult = await readShardManifest(shardPath);
   const manifest = resolveManifestForHealth(
@@ -19101,7 +19338,7 @@ name: ${name}
 shorthand: ${shorthand2}
 description: ${name} shard
 `;
-        await writeFile72(join102(shardPath, "shard.yaml"), yaml);
+        await writeFile82(join122(shardPath, "shard.yaml"), yaml);
       },
       actionLabel: `Create shard.yaml`
     });
@@ -19139,9 +19376,9 @@ description: ${name} shard
     }
   }
   if (manifest) {
-    const yamlPath = join102(shardPath, "shard.yaml");
+    const yamlPath = join122(shardPath, "shard.yaml");
     try {
-      const yamlContent = await readFile62(yamlPath, "utf-8");
+      const yamlContent = await readFile82(yamlPath, "utf-8");
       if (/^state\s*:/m.test(yamlContent)) {
         results.push({
           check: "shard.yaml/state",
@@ -19187,14 +19424,14 @@ description: ${name} shard
     });
   }
   for (const dir of SHARD_SPEC_DIRS_SOURCE) {
-    const dirPath = join102(shardPath, dir);
+    const dirPath = join122(shardPath, dir);
     if (!await exists2(dirPath)) {
       results.push({
         check: `${dir}/`,
         status: "warning",
         message: "Missing directory",
         action: async () => {
-          await mkdir92(dirPath, { recursive: true });
+          await mkdir10(dirPath, { recursive: true });
         },
         actionLabel: `Create ${dir}/`
       });
@@ -19202,14 +19439,14 @@ description: ${name} shard
   }
   if (manifest?.folders) {
     for (const folder of manifest.folders) {
-      const meshPath = join102(flintPath, folder);
+      const meshPath = join122(flintPath, folder);
       if (!await exists2(meshPath)) {
         results.push({
           check: `${folder}`,
           status: "warning",
           message: "Declared Mesh folder missing",
           action: async () => {
-            await mkdir92(meshPath, { recursive: true });
+            await mkdir10(meshPath, { recursive: true });
           },
           actionLabel: `Create ${folder}`
         });
@@ -19224,7 +19461,7 @@ description: ${name} shard
     { file: "MIGRATIONS.md", content: (_name) => "" }
   ];
   for (const { file, content } of rootMarkdownChecks) {
-    const filePath = join102(shardPath, file);
+    const filePath = join122(shardPath, file);
     if (!await exists2(filePath)) {
       const shardDisplayName = manifest?.name || stripShardFolderPrefix(folderName);
       results.push({
@@ -19232,7 +19469,7 @@ description: ${name} shard
         status: "warning",
         message: `Missing ${file}`,
         action: async () => {
-          await writeFile72(filePath, content(shardDisplayName));
+          await writeFile82(filePath, content(shardDisplayName));
         },
         actionLabel: `Create ${file}`
       });
@@ -19245,10 +19482,10 @@ description: ${name} shard
   if (manifest && manifest["shard-spec"] === "0.2.0") {
     const descDirs = ["skills", "workflows", "templates", "knowledge"];
     for (const dir of descDirs) {
-      const files = await collectMarkdownRelativePaths(join102(shardPath, dir));
+      const files = await collectMarkdownRelativePaths(join122(shardPath, dir));
       for (const relativeFile of files) {
-        const filePath = join102(shardPath, dir, relativeFile);
-        const content = await readFile62(filePath, "utf-8");
+        const filePath = join122(shardPath, dir, relativeFile);
+        const content = await readFile82(filePath, "utf-8");
         const parsed = parseFrontmatterRecord(content);
         if (!parsed || !parsed.description || typeof parsed.description !== "string" || !parsed.description.trim()) {
           results.push({
@@ -19289,7 +19526,7 @@ async function getShardInfo(flintPath, identifier) {
   const installed = await getAllShardsWithVersions(flintPath);
   const match2 = resolveInstalledShardInfo(installed, identifier);
   if (match2) {
-    const shardPath = join102(flintPath, "Shards", match2.folderName);
+    const shardPath = join122(flintPath, "Shards", match2.folderName);
     const manifestResult = await readShardManifest(shardPath);
     const manifest = resolveManifestForHealth(
       manifestResult?.manifest,
@@ -19305,10 +19542,10 @@ async function getShardInfo(flintPath, identifier) {
       dev: decl ? decl.kind === "dev-remote" : false,
       mode: decl ? decl.kind : "installed",
       folderName: match2.folderName,
-      skillCount: await countFiles2(join102(shardPath, "skills")),
-      templateCount: await countFiles2(join102(shardPath, "templates")),
-      workflowCount: await countFiles2(join102(shardPath, "workflows")),
-      knowledgeCount: await countFiles2(join102(shardPath, "knowledge"))
+      skillCount: await countFiles2(join122(shardPath, "skills")),
+      templateCount: await countFiles2(join122(shardPath, "templates")),
+      workflowCount: await countFiles2(join122(shardPath, "workflows")),
+      knowledgeCount: await countFiles2(join122(shardPath, "knowledge"))
     };
   }
   return null;
@@ -19326,13 +19563,13 @@ async function getInstalledShardRuntimeInfo(flintPath, identifier) {
   }
   return {
     folderName: shard.folderName,
-    shardPath: join112(flintPath, "Shards", shard.folderName)
+    shardPath: join132(flintPath, "Shards", shard.folderName)
   };
 }
 async function discoverScripts(shardPath) {
-  const scriptsDir = join112(shardPath, "scripts");
+  const scriptsDir = join132(shardPath, "scripts");
   try {
-    const entries = await readdir62(scriptsDir, { withFileTypes: true });
+    const entries = await readdir72(scriptsDir, { withFileTypes: true });
     const scripts = [];
     for (const entry of entries) {
       if (!entry.isFile() || !entry.name.endsWith(".js")) continue;
@@ -19346,7 +19583,7 @@ async function discoverScripts(shardPath) {
       }
       scripts.push({
         name,
-        path: join112(scriptsDir, entry.name)
+        path: join132(scriptsDir, entry.name)
       });
     }
     return scripts;
@@ -19370,12 +19607,12 @@ async function runShardScript(flintPath, shardIdentifier, scriptName, args = [])
     const scriptNames = scripts.map((s) => s.name).join(", ");
     throw new Error(`Script "${scriptName}" not found. Available: ${scriptNames}`);
   }
-  const resolvedShardPath = resolve42(shard.shardPath);
-  const scriptPath = resolve42(script.path);
+  const resolvedShardPath = resolve5(shard.shardPath);
+  const scriptPath = resolve5(script.path);
   if (!isWithinRoot2(resolvedShardPath, scriptPath)) {
     throw new Error(`Invalid script path outside shard: ${script.path}`);
   }
-  const resolvedFlintPath = resolve42(flintPath);
+  const resolvedFlintPath = resolve5(flintPath);
   return new Promise((resolve82, reject) => {
     const child = spawn22("node", [scriptPath, ...args], {
       cwd: resolvedFlintPath,
@@ -19426,7 +19663,7 @@ async function syncFlint(flintPath) {
     await stat62(flintConfigDir);
   } catch {
     try {
-      await mkdir10(flintConfigDir, { recursive: true });
+      await mkdir11(flintConfigDir, { recursive: true });
       result.bootstrap.created = true;
     } catch (err) {
       result.errors.push({
@@ -19436,11 +19673,11 @@ async function syncFlint(flintPath) {
     }
   }
   for (const dir of STANDARD_DIRECTORIES) {
-    const dirPath = join122(flintPath, dir);
+    const dirPath = join142(flintPath, dir);
     try {
       await stat62(dirPath);
     } catch {
-      await mkdir10(dirPath, { recursive: true });
+      await mkdir11(dirPath, { recursive: true });
       result.bootstrap.directories.push(dir);
     }
   }
@@ -19449,7 +19686,7 @@ async function syncFlint(flintPath) {
   if (!config) {
     throw new Error("flint.toml not found. Run flint init first.");
   }
-  const obsidianDir = join122(flintPath, ".obsidian");
+  const obsidianDir = join142(flintPath, ".obsidian");
   try {
     await stat62(obsidianDir);
     result.obsidian.existed = true;
@@ -19508,10 +19745,10 @@ async function syncFlint(flintPath) {
       const currentFolderName = basename42(flintPath);
       const expectedFolderName = `(Flint) ${tomlName}`;
       if (currentFolderName !== expectedFolderName) {
-        const parentDir = dirname32(flintPath);
-        const newPath = join122(parentDir, expectedFolderName);
+        const parentDir = dirname42(flintPath);
+        const newPath = join142(parentDir, expectedFolderName);
         try {
-          await rename52(flintPath, newPath);
+          await rename62(flintPath, newPath);
           currentFlintPath = newPath;
           result.registry.oldPath = flintPath;
           result.registry.newPath = newPath;
@@ -19555,9 +19792,9 @@ async function syncFlint(flintPath) {
       console.warn(`Registry sync warning: ${err instanceof Error ? err.message : String(err)}`);
     }
   }
-  const inboxDir = join122(currentFlintPath, "Inbox");
+  const inboxDir = join142(currentFlintPath, "Inbox");
   try {
-    const inboxEntries = await readdir72(inboxDir);
+    const inboxEntries = await readdir82(inboxDir);
     if (inboxEntries.length === 0) {
       await rm52(inboxDir, { recursive: true });
     }
@@ -19585,134 +19822,6 @@ async function syncFlint(flintPath) {
   }
   return result;
 }
-function getObsidianConfigPath() {
-  const p = platform22();
-  if (p === "darwin") {
-    return join132(homedir32(), "Library", "Application Support", "obsidian", "obsidian.json");
-  }
-  if (p === "win32") {
-    const appData = process.env.APPDATA ?? join132(homedir32(), "AppData", "Roaming");
-    return join132(appData, "obsidian", "obsidian.json");
-  }
-  return join132(homedir32(), ".config", "obsidian", "obsidian.json");
-}
-async function readObsidianConfig(configPath = getObsidianConfigPath()) {
-  if (!existsSync3(configPath)) {
-    return { vaults: {} };
-  }
-  const raw = await readFile72(configPath, "utf-8");
-  const parsed = JSON.parse(raw);
-  return {
-    ...parsed,
-    vaults: parsed.vaults ?? {}
-  };
-}
-async function writeObsidianConfig(config, configPath = getObsidianConfigPath()) {
-  await mkdir11(dirname42(configPath), { recursive: true });
-  if (existsSync3(configPath)) {
-    const current = await readFile72(configPath, "utf-8");
-    await writeFile82(`${configPath}.backup`, current, "utf-8");
-  }
-  const tempPath = `${configPath}.tmp.${process.pid}.${Date.now()}`;
-  await writeFile82(tempPath, JSON.stringify(config), "utf-8");
-  await rename62(tempPath, configPath);
-}
-function findVaultIdByPath(config, absPath) {
-  const target = resolve5(absPath);
-  for (const [id, vault] of Object.entries(config.vaults)) {
-    if (resolve5(vault.path) === target) return id;
-  }
-  return null;
-}
-function generateVaultId() {
-  return randomBytes2(8).toString("hex");
-}
-async function registerVault(absPath, configPath = getObsidianConfigPath()) {
-  const target = resolve5(absPath);
-  const config = await readObsidianConfig(configPath);
-  const existing = findVaultIdByPath(config, target);
-  if (existing) {
-    return { id: existing, alreadyRegistered: true };
-  }
-  const id = generateVaultId();
-  config.vaults[id] = { path: target, ts: Date.now() };
-  await writeObsidianConfig(config, configPath);
-  return { id, alreadyRegistered: false };
-}
-async function readDiscovery(path202 = DISCOVERY_FILE_PATH) {
-  if (!existsSync22(path202)) return null;
-  try {
-    const raw = await readFile82(path202, "utf-8");
-    const parsed = JSON.parse(raw);
-    if (typeof parsed.port !== "number" || typeof parsed.pid !== "number") return null;
-    return parsed;
-  } catch {
-    return null;
-  }
-}
-function isPidAlive(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (err) {
-    if (err.code === "EPERM") return true;
-    return false;
-  }
-}
-async function getLivePlugin(path202 = DISCOVERY_FILE_PATH) {
-  const record = await readDiscovery(path202);
-  if (!record) return null;
-  if (!isPidAlive(record.pid)) return null;
-  return record;
-}
-async function postOpenVault(port, absPath, timeoutMs = 2e3) {
-  return new Promise((resolvePromise) => {
-    const body = JSON.stringify({ path: absPath });
-    const req = request(
-      {
-        hostname: "127.0.0.1",
-        port,
-        path: "/vault/open",
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "Content-Length": Buffer.byteLength(body)
-        },
-        timeout: timeoutMs
-      },
-      (res) => {
-        const chunks = [];
-        res.on("data", (chunk) => chunks.push(chunk));
-        res.on("end", () => {
-          const text = Buffer.concat(chunks).toString("utf-8");
-          try {
-            const parsed = JSON.parse(text);
-            if (parsed.ok === true && typeof parsed.id === "string") {
-              resolvePromise({ ok: true, id: parsed.id, registered: Boolean(parsed.registered) });
-              return;
-            }
-            const errorMessage = typeof parsed.error === "string" ? parsed.error : `unexpected response (status ${res.statusCode ?? "unknown"})`;
-            resolvePromise({ ok: false, error: errorMessage });
-          } catch {
-            resolvePromise({ ok: false, error: `invalid JSON response (status ${res.statusCode ?? "unknown"})` });
-          }
-        });
-        res.on("error", (err) => {
-          resolvePromise({ ok: false, error: err.message });
-        });
-      }
-    );
-    req.on("timeout", () => {
-      req.destroy();
-      resolvePromise({ ok: false, error: `request timed out after ${timeoutMs}ms` });
-    });
-    req.on("error", (err) => {
-      resolvePromise({ ok: false, error: err.message });
-    });
-    req.write(body);
-    req.end();
-  });
-}
 function getBuiltinPresetsDir() {
   return join152(__dirname2, "presets");
 }
@@ -19746,7 +19855,7 @@ async function loadPresetFromDir(presetDir) {
 async function discoverPresetsFromDir(presetsDir) {
   const presets = /* @__PURE__ */ new Map();
   try {
-    const entries = await readdir82(presetsDir, { withFileTypes: true });
+    const entries = await readdir92(presetsDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
       const presetDir = join152(presetsDir, entry.name);
@@ -19980,7 +20089,7 @@ function parseExportDocument(content, name, sourcePath) {
 }
 async function findFilesRecursively(dir, fileName, matches = []) {
   try {
-    const entries = await readdir92(dir, { withFileTypes: true });
+    const entries = await readdir102(dir, { withFileTypes: true });
     entries.sort((a, b) => a.name.localeCompare(b.name));
     for (const entry of entries) {
       const fullPath = join17(dir, entry.name);
@@ -20089,7 +20198,7 @@ async function scanExportEligible(flintPath) {
 }
 async function findExportTaggedFiles(dir, flintPath, declared, results) {
   try {
-    const entries = await readdir92(dir, { withFileTypes: true });
+    const entries = await readdir102(dir, { withFileTypes: true });
     for (const entry of entries) {
       const fullPath = join17(dir, entry.name);
       if (entry.isDirectory()) {
@@ -21084,7 +21193,7 @@ function registerAllFeatures() {
   for (const feature of allFeatures) registerFeature(feature);
   registered = true;
 }
-var STANDARD_DIRECTORIES, execAsync3, OBSIDIAN_REPO_URL, OBSIDIAN_WINDOWS_REPO_URL, GLOBAL_CONFIG_FILENAME, execAsync22, DEFAULT_PLATES_ORG, PLATE_SKIP_DIRS, FRONTMATTER_RE, SKIP_DIRS, execFileAsync6, execAsync32, REFERENCES_LOCAL_FILE, FulfillmentSchema, ReferencesLocalSchema, FALLBACK2, execFileAsync22, TINDERBOX_CONFIG_FILENAME, REQUIRED_FLINT_DIRS, TINDERBOX_GITIGNORE_HEADER, TINDERBOX_GITIGNORE_PATTERN, SHARD_SYSTEM_FOLDERS, SHARD_SPEC_DIRS_INSTALLED, SHARD_SPEC_DIRS_SOURCE, OPTIONAL_SHARD_ROOT_DIRS, SHARD_DIRS_ALLOWING_NESTING, ROOT_MARKDOWN_FILES, SHARD_NAME_PATTERN, SHARD_NAME_REGEX, SHARD_SEMVER_REGEX, SHARD_SCRIPT_REGEX, DEV_SHARD_SCRIPT_REGEX, MARKDOWN_FILENAME_LINE_REGEX, MARKDOWN_CODE_FENCE_REGEX, MARKDOWN_COMMENT_REGEX, MARKDOWN_LIFECYCLE_REGEX, SKILL_REFERENCE_REGEX, WORKFLOW_REFERENCE_REGEX, TEMPLATE_REFERENCE_REGEX, KNOWLEDGE_REFERENCE_REGEX, HUMAN_CHECKPOINT_REGEX, TYPE_DEFINITION_PROPERTIES, TEMPLATE_LINK_TARGET_REGEX, VALID_COMMAND_NAME, DISCOVERY_FILE_PATH, __dirname2, presetsCache, PROMPTS_BASE_PATH, IntentFrameSchema, EntityFrameSchema, features, KERNEL_FEATURE_ID, EMPTY_INTENT, EMPTY_ENTITY, IDENTITY_FEATURE_ID, IDENTITY_MARKERS_DIR, identity2, BUNDLE_EXPORTS_FEATURE_ID, BUNDLE_EXPORTS_DIR, BUNDLE_EXPORTS_MARKERS_DIR, BundleExportEntrySchema, bundleExports, CODEBASE_REFERENCES_FEATURE_ID, CODEBASE_REFERENCES_MARKERS_DIR, CodebaseReferenceEntrySchema, codebaseReferences, FLINT_BUNDLE_REFERENCES_FEATURE_ID, FLINT_BUNDLE_REFERENCES_MARKERS_DIR, FlintBundleReferenceEntrySchema, flintBundleReferences, FLINT_REFERENCES_FEATURE_ID, FLINT_REFERENCES_MARKERS_DIR, FlintReferenceEntrySchema, flintReferences, LATTICE_REFERENCES_FEATURE_ID, LATTICE_REFERENCES_MARKERS_DIR, LatticeReferenceEntrySchema, latticeReferences, execFileAsync32, WORKSPACE_REPOS_FEATURE_ID, WORKSPACE_REPOS_DIR, WORKSPACE_REPOS_MARKERS_DIR, WorkspaceRepoEntrySchema, workspaceRepos, NAME, OWNER_REPO, LOCAL_SOURCE, InstalledShardEntrySchema, DevRemoteShardEntrySchema, DevLocalShardEntrySchema, DEV_LOCAL_SHARDS_FEATURE_ID, SHARDS_DIR, REQUIRED_ROOT_FILES, devLocalShards, DEV_REMOTE_SHARDS_FEATURE_ID, SHARDS_DIR2, REQUIRED_ROOT_FILES2, devRemoteShards, INSTALLED_SHARDS_FEATURE_ID, SHARDS_DIR3, installedShards, SHARD_REPOS_FEATURE_ID, SHARDS_DIR4, shardRepos, FLINT_BUNDLES_FEATURE_ID, FLINT_BUNDLES_DIR, FLINT_BUNDLES_MARKERS_DIR, FlintBundleEntrySchema, flintBundles, execFileAsync42, SOURCE_REPOS_FEATURE_ID, SOURCE_REPOS_DIR, SOURCE_REPOS_MARKERS_DIR, SourceRepoEntrySchema, sourceRepos, allFeatures, registered;
+var STANDARD_DIRECTORIES, execAsync3, OBSIDIAN_REPO_URL, OBSIDIAN_WINDOWS_REPO_URL, GLOBAL_CONFIG_FILENAME, execAsync22, DEFAULT_PLATES_ORG, PLATE_SKIP_DIRS, FRONTMATTER_RE, SKIP_DIRS, execFileAsync6, execAsync32, REFERENCES_LOCAL_FILE, FulfillmentSchema, ReferencesLocalSchema, FALLBACK2, DISCOVERY_DIR, execFileAsync22, TINDERBOX_CONFIG_FILENAME, REQUIRED_FLINT_DIRS, TINDERBOX_GITIGNORE_HEADER, TINDERBOX_GITIGNORE_PATTERN, SHARD_SYSTEM_FOLDERS, SHARD_SPEC_DIRS_INSTALLED, SHARD_SPEC_DIRS_SOURCE, OPTIONAL_SHARD_ROOT_DIRS, SHARD_DIRS_ALLOWING_NESTING, ROOT_MARKDOWN_FILES, SHARD_NAME_PATTERN, SHARD_NAME_REGEX, SHARD_SEMVER_REGEX, SHARD_SCRIPT_REGEX, DEV_SHARD_SCRIPT_REGEX, MARKDOWN_FILENAME_LINE_REGEX, MARKDOWN_CODE_FENCE_REGEX, MARKDOWN_COMMENT_REGEX, MARKDOWN_LIFECYCLE_REGEX, SKILL_REFERENCE_REGEX, WORKFLOW_REFERENCE_REGEX, TEMPLATE_REFERENCE_REGEX, KNOWLEDGE_REFERENCE_REGEX, HUMAN_CHECKPOINT_REGEX, TYPE_DEFINITION_PROPERTIES, TEMPLATE_LINK_TARGET_REGEX, VALID_COMMAND_NAME, __dirname2, presetsCache, PROMPTS_BASE_PATH, IntentFrameSchema, EntityFrameSchema, features, KERNEL_FEATURE_ID, EMPTY_INTENT, EMPTY_ENTITY, IDENTITY_FEATURE_ID, IDENTITY_MARKERS_DIR, identity2, BUNDLE_EXPORTS_FEATURE_ID, BUNDLE_EXPORTS_DIR, BUNDLE_EXPORTS_MARKERS_DIR, BundleExportEntrySchema, bundleExports, CODEBASE_REFERENCES_FEATURE_ID, CODEBASE_REFERENCES_MARKERS_DIR, CodebaseReferenceEntrySchema, codebaseReferences, FLINT_BUNDLE_REFERENCES_FEATURE_ID, FLINT_BUNDLE_REFERENCES_MARKERS_DIR, FlintBundleReferenceEntrySchema, flintBundleReferences, FLINT_REFERENCES_FEATURE_ID, FLINT_REFERENCES_MARKERS_DIR, FlintReferenceEntrySchema, flintReferences, LATTICE_REFERENCES_FEATURE_ID, LATTICE_REFERENCES_MARKERS_DIR, LatticeReferenceEntrySchema, latticeReferences, execFileAsync32, WORKSPACE_REPOS_FEATURE_ID, WORKSPACE_REPOS_DIR, WORKSPACE_REPOS_MARKERS_DIR, WorkspaceRepoEntrySchema, workspaceRepos, NAME, OWNER_REPO, LOCAL_SOURCE, InstalledShardEntrySchema, DevRemoteShardEntrySchema, DevLocalShardEntrySchema, DEV_LOCAL_SHARDS_FEATURE_ID, SHARDS_DIR, REQUIRED_ROOT_FILES, devLocalShards, DEV_REMOTE_SHARDS_FEATURE_ID, SHARDS_DIR2, REQUIRED_ROOT_FILES2, devRemoteShards, INSTALLED_SHARDS_FEATURE_ID, SHARDS_DIR3, installedShards, SHARD_REPOS_FEATURE_ID, SHARDS_DIR4, shardRepos, FLINT_BUNDLES_FEATURE_ID, FLINT_BUNDLES_DIR, FLINT_BUNDLES_MARKERS_DIR, FlintBundleEntrySchema, flintBundles, execFileAsync42, SOURCE_REPOS_FEATURE_ID, SOURCE_REPOS_DIR, SOURCE_REPOS_MARKERS_DIR, SourceRepoEntrySchema, sourceRepos, allFeatures, registered;
 var init_dist4 = __esm({
   "../../packages/flint/dist/index.js"() {
     "use strict";
@@ -21153,6 +21262,7 @@ var init_dist4 = __esm({
       bundles: [],
       lattices: []
     };
+    DISCOVERY_DIR = join102(homedir32(), ".nuucognition", "obsidian-plugins");
     execFileAsync22 = promisify52(execFile22);
     TINDERBOX_CONFIG_FILENAME = "tinderbox.toml";
     REQUIRED_FLINT_DIRS = [
@@ -21203,7 +21313,6 @@ var init_dist4 = __esm({
     TYPE_DEFINITION_PROPERTIES = ["Tag", "Naming", "Location", "Archive", "Lifecycle", "Template"];
     TEMPLATE_LINK_TARGET_REGEX = /\[\[(tmp-[A-Za-z0-9_.-]+)\]\]/g;
     VALID_COMMAND_NAME = /^[a-z0-9][a-z0-9_-]*$/;
-    DISCOVERY_FILE_PATH = join142(homedir4(), ".nuu", "obsidian-plugin.json");
     __dirname2 = dirname52(fileURLToPath2(import.meta.url));
     presetsCache = null;
     PROMPTS_BASE_PATH = resolvePromptsBasePath();
@@ -25317,14 +25426,14 @@ var require_emoji_regex2 = __commonJS({
 var require_string_width2 = __commonJS({
   "../../node_modules/.pnpm/string-width@4.2.3/node_modules/string-width/index.js"(exports, module) {
     "use strict";
-    var stripAnsi5 = require_strip_ansi2();
+    var stripAnsi6 = require_strip_ansi2();
     var isFullwidthCodePoint2 = require_is_fullwidth_code_point2();
     var emojiRegex2 = require_emoji_regex2();
     var stringWidth3 = (string) => {
       if (typeof string !== "string" || string.length === 0) {
         return 0;
       }
-      string = stripAnsi5(string);
+      string = stripAnsi6(string);
       if (string.length === 0) {
         return 0;
       }
@@ -25510,7 +25619,7 @@ var require_utils2 = __commonJS({
       }
       return unwindState(state, ret);
     }
-    function truncate5(str, desiredLength, truncateChar) {
+    function truncate6(str, desiredLength, truncateChar) {
       truncateChar = truncateChar || "\u2026";
       let lengthOfStr = strlen(str);
       if (lengthOfStr <= desiredLength) {
@@ -25644,7 +25753,7 @@ var require_utils2 = __commonJS({
       strlen,
       repeat,
       pad: pad3,
-      truncate: truncate5,
+      truncate: truncate6,
       mergeOptions,
       wordWrap: multiLineWordWrap,
       colorizeLines,
@@ -27294,7 +27403,7 @@ var require_core2 = __commonJS({
       return match2 && match2.index === 0;
     }
     var BACKREF_RE = /\[(?:[^\\\]]|\\.)*\]|\(\??|\\([1-9][0-9]*)|\\./;
-    function join49(regexps, separator = "|") {
+    function join51(regexps, separator = "|") {
       let numCaptures = 0;
       return regexps.map((regex3) => {
         numCaptures += 1;
@@ -27598,7 +27707,7 @@ var require_core2 = __commonJS({
             this.exec = () => null;
           }
           const terminators = this.regexes.map((el) => el[1]);
-          this.matcherRe = langRe(join49(terminators), true);
+          this.matcherRe = langRe(join51(terminators), true);
           this.lastIndex = 0;
         }
         /** @param {string} s */
@@ -82706,7 +82815,7 @@ var init_lib = __esm({
 });
 
 // ../../node_modules/.pnpm/environment@1.1.0/node_modules/environment/index.js
-var isBrowser2, isNode2, isBun2, isDeno2, isElectron2, isJsDom2, isWebWorker2, isDedicatedWorker2, isSharedWorker2, isServiceWorker2, platform7, isMacOs2, isWindows3, isLinux2, isIos2, isAndroid2;
+var isBrowser2, isNode2, isBun2, isDeno2, isElectron2, isJsDom2, isWebWorker2, isDedicatedWorker2, isSharedWorker2, isServiceWorker2, platform6, isMacOs2, isWindows3, isLinux2, isIos2, isAndroid2;
 var init_environment = __esm({
   "../../node_modules/.pnpm/environment@1.1.0/node_modules/environment/index.js"() {
     "use strict";
@@ -82720,12 +82829,12 @@ var init_environment = __esm({
     isDedicatedWorker2 = typeof DedicatedWorkerGlobalScope !== "undefined" && globalThis instanceof DedicatedWorkerGlobalScope;
     isSharedWorker2 = typeof SharedWorkerGlobalScope !== "undefined" && globalThis instanceof SharedWorkerGlobalScope;
     isServiceWorker2 = typeof ServiceWorkerGlobalScope !== "undefined" && globalThis instanceof ServiceWorkerGlobalScope;
-    platform7 = globalThis.navigator?.userAgentData?.platform;
-    isMacOs2 = platform7 === "macOS" || globalThis.navigator?.platform === "MacIntel" || globalThis.navigator?.userAgent?.includes(" Mac ") === true || globalThis.process?.platform === "darwin";
-    isWindows3 = platform7 === "Windows" || globalThis.navigator?.platform === "Win32" || globalThis.process?.platform === "win32";
-    isLinux2 = platform7 === "Linux" || globalThis.navigator?.platform?.startsWith("Linux") === true || globalThis.navigator?.userAgent?.includes(" Linux ") === true || globalThis.process?.platform === "linux";
-    isIos2 = platform7 === "iOS" || globalThis.navigator?.platform === "MacIntel" && globalThis.navigator?.maxTouchPoints > 1 || /iPad|iPhone|iPod/.test(globalThis.navigator?.platform);
-    isAndroid2 = platform7 === "Android" || globalThis.navigator?.platform === "Android" || globalThis.navigator?.userAgent?.includes(" Android ") === true || globalThis.process?.platform === "android";
+    platform6 = globalThis.navigator?.userAgentData?.platform;
+    isMacOs2 = platform6 === "macOS" || globalThis.navigator?.platform === "MacIntel" || globalThis.navigator?.userAgent?.includes(" Mac ") === true || globalThis.process?.platform === "darwin";
+    isWindows3 = platform6 === "Windows" || globalThis.navigator?.platform === "Win32" || globalThis.process?.platform === "win32";
+    isLinux2 = platform6 === "Linux" || globalThis.navigator?.platform?.startsWith("Linux") === true || globalThis.navigator?.userAgent?.includes(" Linux ") === true || globalThis.process?.platform === "linux";
+    isIos2 = platform6 === "iOS" || globalThis.navigator?.platform === "MacIntel" && globalThis.navigator?.maxTouchPoints > 1 || /iPad|iPhone|iPod/.test(globalThis.navigator?.platform);
+    isAndroid2 = platform6 === "Android" || globalThis.navigator?.platform === "Android" || globalThis.navigator?.userAgent?.includes(" Android ") === true || globalThis.process?.platform === "android";
   }
 });
 
@@ -83777,7 +83886,7 @@ var require_brace_expansion = __commonJS({
 // src/index.ts
 import { readFileSync as readFileSync17 } from "fs";
 import { fileURLToPath as fileURLToPath8 } from "url";
-import { dirname as dirname13, join as join48 } from "path";
+import { dirname as dirname13, join as join50 } from "path";
 
 // ../../../main/packages/cli-core/dist/index.js
 import { createRequire as __createRequire } from "module";
@@ -84858,7 +84967,7 @@ var require_suggestSimilar = __commonJS2({
 var require_command = __commonJS2({
   "../../node_modules/.pnpm/commander@12.1.0/node_modules/commander/lib/command.js"(exports) {
     "use strict";
-    var EventEmitter3 = __require2("events").EventEmitter;
+    var EventEmitter4 = __require2("events").EventEmitter;
     var childProcess2 = __require2("child_process");
     var path210 = __require2("path");
     var fs62 = __require2("fs");
@@ -84868,7 +84977,7 @@ var require_command = __commonJS2({
     var { Help: Help2 } = require_help();
     var { Option: Option2, DualOptions } = require_option();
     var { suggestSimilar } = require_suggestSimilar();
-    var Command2 = class _Command extends EventEmitter3 {
+    var Command2 = class _Command extends EventEmitter4 {
       /**
        * Initialize a new `Command`.
        *
@@ -87409,7 +87518,7 @@ var require_core = __commonJS2({
       return match2 && match2.index === 0;
     }
     var BACKREF_RE = /\[(?:[^\\\]]|\\.)*\]|\(\??|\\([1-9][0-9]*)|\\./;
-    function join49(regexps, separator = "|") {
+    function join410(regexps, separator = "|") {
       let numCaptures = 0;
       return regexps.map((regex22) => {
         numCaptures += 1;
@@ -87713,7 +87822,7 @@ var require_core = __commonJS2({
             this.exec = () => null;
           }
           const terminators = this.regexes.map((el) => el[1]);
-          this.matcherRe = langRe(join49(terminators), true);
+          this.matcherRe = langRe(join410(terminators), true);
           this.lastIndex = 0;
         }
         /** @param {string} s */
@@ -146687,7 +146796,7 @@ var require_buffer_list = __commonJS2({
         }
       }, {
         key: "join",
-        value: function join49(s) {
+        value: function join410(s) {
           if (this.length === 0) return "";
           var p = this.head;
           var ret = "" + p.data;
@@ -156419,6 +156528,7 @@ var FEATURES = createFeatureRegistry([
   { id: "plan", tier: "prod", type: "command", description: "Show drift between intent and actual state (kernel)", 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: "gigasync", tier: "prod", type: "command", description: "Chain git sync, obsidian update, shard update, and sync", requiresAuth: false },
   { id: "shard", tier: "prod", type: "command", description: "Shard management", requiresAuth: false },
   { id: "git", tier: "prod", type: "command", description: "Git integration", requiresAuth: false },
   { id: "config", tier: "prod", type: "command", description: "Configuration management", requiresAuth: false },
@@ -156515,14 +156625,12 @@ var PROFILE_MIGRATIONS = [
 
 // src/commands/flint/init.ts
 init_dist4();
-import { execSync as execSync2 } from "child_process";
-import { platform as platform4 } from "os";
 import { resolve as resolve9, join as join19 } from "path";
 import { existsSync as existsSync5 } from "fs";
 import { mkdtemp as mkdtemp3, rm as rm9, rename as rename9 } from "fs/promises";
 import { tmpdir as tmpdir3 } from "os";
-import { exec as exec4 } from "child_process";
-import { promisify as promisify9 } from "util";
+import { exec as exec5 } from "child_process";
+import { promisify as promisify10 } from "util";
 
 // src/utils.ts
 import { homedir as homedir5 } from "os";
@@ -156651,22 +156759,77 @@ function formatPayload(payload) {
   return export_pc.dim(parts.join(" "));
 }
 
-// src/commands/flint/init.ts
+// src/open-flint.ts
+import { exec as exec4 } from "child_process";
+import { promisify as promisify9 } from "util";
+import { platform as platform4 } from "os";
+init_dist4();
 var execAsync4 = promisify9(exec4);
-function openObsidianVaultChooser() {
+async function launchObsidianAtPath(path30) {
   const os7 = platform4();
-  const uri = "obsidian://choose-vault";
-  try {
-    if (os7 === "darwin") {
-      execSync2(`open "${uri}"`, { stdio: "pipe", windowsHide: true });
-    } else if (os7 === "win32") {
-      execSync2(`start "" "${uri}"`, { stdio: "pipe", windowsHide: true });
-    } else {
-      execSync2(`xdg-open "${uri}"`, { stdio: "pipe", windowsHide: true });
+  if (os7 === "darwin") {
+    await execAsync4(`open -a "Obsidian" "${path30}"`);
+  } else if (os7 === "win32") {
+    throw new Error("Cold launch on Windows is disabled \u2014 start Obsidian first so the NUU plugin can route the open request.");
+  } else {
+    try {
+      await execAsync4(`obsidian "${path30}"`);
+    } catch {
+      await execAsync4(`xdg-open "${path30}"`);
     }
-  } catch {
   }
 }
+async function openViaPlugin(absPath, port) {
+  const result = await postOpenVault(port, absPath);
+  if (result.ok) {
+    const action = result.registered ? "registered + switched" : "switched";
+    console.log(export_pc.green(`Plugin running \u2014 ${action} via NUU Obsidian (id: ${result.id})`));
+    return true;
+  }
+  console.log(export_pc.yellow(`Plugin call failed: ${result.error} \u2014 falling back to cold launch.`));
+  return false;
+}
+async function coldOpen(absPath, alreadyRegistered) {
+  if (!alreadyRegistered) {
+    const result = await registerVault(absPath);
+    console.log(export_pc.dim(`Cold launch \u2014 registered new vault (id: ${result.id}) and starting Obsidian`));
+  } else {
+    console.log(export_pc.dim("Vault already registered \u2014 launching Obsidian"));
+  }
+  await launchObsidianAtPath(absPath);
+}
+async function openFlintAtPath(absPath, options3 = {}) {
+  const config = await readObsidianConfig();
+  const registered2 = findVaultIdByPath(config, absPath) !== null;
+  const plugin = options3.usePlugin === false ? null : await getLivePlugin();
+  if (registered2 && !plugin) {
+    console.log(export_pc.dim(`Vault already registered, opening ${absPath}...`));
+    await launchObsidianAtPath(absPath);
+    console.log(export_pc.green("Opened in Obsidian"));
+    return;
+  }
+  if (registered2 && plugin) {
+    console.log(export_pc.dim(`Vault registered and Obsidian is running \u2014 focusing ${absPath}`));
+    if (platform4() === "win32") {
+      const ok = await openViaPlugin(absPath, plugin.port);
+      if (ok) return;
+      throw new Error("Plugin call failed and cold launch is disabled on Windows.");
+    }
+    await launchObsidianAtPath(absPath);
+    console.log(export_pc.green("Opened in Obsidian"));
+    return;
+  }
+  if (!registered2 && plugin) {
+    const ok = await openViaPlugin(absPath, plugin.port);
+    if (ok) return;
+    await coldOpen(absPath, false);
+    return;
+  }
+  await coldOpen(absPath, false);
+}
+
+// src/commands/flint/init.ts
+var execAsync5 = promisify10(exec5);
 function reportSyncResult(result) {
   if (result.obsidian.cloned) {
     console.log();
@@ -156691,7 +156854,7 @@ Cloning ${export_pc.cyan(url)}...
 `);
     tempDir = await mkdtemp3(join19(tmpdir3(), "flint-clone-"));
     try {
-      await execAsync4(`git clone "${url}" "${tempDir}"`, { timeout: 12e4, windowsHide: true });
+      await execAsync5(`git clone "${url}" "${tempDir}"`, { timeout: 12e4, windowsHide: true });
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);
       throw new Error(`Git clone failed: ${message}`);
@@ -156829,8 +156992,7 @@ Creating flint: ${export_pc.bold(name)}
       printResult(kernelResult, true);
     }
     if (result.obsidian.cloned) {
-      console.log(export_pc.dim("\nOpening Obsidian vault chooser..."));
-      openObsidianVaultChooser();
+      await openFlintAtPath(entry.path);
     }
     console.log();
   } catch (err) {
@@ -157138,72 +157300,6 @@ function printScopeLine(label, pending) {
 // src/commands/flint/open.ts
 init_dist4();
 import { resolve as resolve10 } from "path";
-
-// src/open-flint.ts
-import { exec as exec5 } from "child_process";
-import { promisify as promisify10 } from "util";
-import { platform as platform5 } from "os";
-init_dist4();
-var execAsync5 = promisify10(exec5);
-async function launchObsidianAtPath(path30) {
-  const os7 = platform5();
-  if (os7 === "darwin") {
-    await execAsync5(`open -a "Obsidian" "${path30}"`);
-  } else if (os7 === "win32") {
-    await execAsync5(`start "" "${path30}"`);
-  } else {
-    try {
-      await execAsync5(`obsidian "${path30}"`);
-    } catch {
-      await execAsync5(`xdg-open "${path30}"`);
-    }
-  }
-}
-async function openViaPlugin(absPath, port) {
-  const result = await postOpenVault(port, absPath);
-  if (result.ok) {
-    const action = result.registered ? "registered + switched" : "switched";
-    console.log(export_pc.green(`Plugin running \u2014 ${action} via NUU Obsidian (id: ${result.id})`));
-    return true;
-  }
-  console.log(export_pc.yellow(`Plugin call failed: ${result.error} \u2014 falling back to cold launch.`));
-  return false;
-}
-async function coldOpen(absPath, alreadyRegistered) {
-  if (!alreadyRegistered) {
-    const result = await registerVault(absPath);
-    console.log(export_pc.dim(`Cold launch \u2014 registered new vault (id: ${result.id}) and starting Obsidian`));
-  } else {
-    console.log(export_pc.dim("Vault already registered \u2014 launching Obsidian"));
-  }
-  await launchObsidianAtPath(absPath);
-}
-async function openFlintAtPath(absPath, options3 = {}) {
-  const config = await readObsidianConfig();
-  const registered2 = findVaultIdByPath(config, absPath) !== null;
-  const plugin = options3.usePlugin === false ? null : await getLivePlugin();
-  if (registered2 && !plugin) {
-    console.log(export_pc.dim(`Vault already registered, opening ${absPath}...`));
-    await launchObsidianAtPath(absPath);
-    console.log(export_pc.green("Opened in Obsidian"));
-    return;
-  }
-  if (registered2 && plugin) {
-    console.log(export_pc.dim(`Vault registered and Obsidian is running \u2014 focusing ${absPath}`));
-    await launchObsidianAtPath(absPath);
-    console.log(export_pc.green("Opened in Obsidian"));
-    return;
-  }
-  if (!registered2 && plugin) {
-    const ok = await openViaPlugin(absPath, plugin.port);
-    if (ok) return;
-    await coldOpen(absPath, false);
-    return;
-  }
-  await coldOpen(absPath, false);
-}
-
-// src/commands/flint/open.ts
 async function resolveFlintPath(flintName) {
   if (flintName) {
     const flints = await getFlintRegistry();
@@ -157590,6 +157686,221 @@ var syncCommand = new Command("sync").description("Sync shards from flint.toml")
   }
 });
 
+// src/commands/flint/gigasync.ts
+import { spawn as spawn4, execSync as execSync2 } from "child_process";
+import { setTimeout as sleep } from "timers/promises";
+import { join as join26 } from "path";
+init_dist4();
+function obsidianHead(flintPath) {
+  try {
+    return execSync2("git rev-parse HEAD", {
+      cwd: join26(flintPath, ".obsidian"),
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"],
+      windowsHide: true
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+var STEPS = [
+  {
+    label: "flint git sync",
+    args: ["git", "sync"],
+    icon: "\u2387",
+    skipIf: async (flintPath) => await isGitInitialized(flintPath) ? null : "git not initialized in this Flint"
+  },
+  {
+    label: "flint obsidian update",
+    args: ["obsidian", "update", "--no-reload"],
+    icon: "\u25C6",
+    before: async (flintPath) => obsidianHead(flintPath),
+    afterNote: async (flintPath, before) => {
+      const after = obsidianHead(flintPath);
+      if (before && after && before !== after) return "reload obsidian to apply";
+      return null;
+    }
+  },
+  { label: "flint shard update", args: ["shard", "update"], icon: "\u2726" },
+  { label: "flint sync", args: ["sync"], icon: "\u21BB" }
+];
+var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var BAR_WIDTH = 32;
+var ANSI_RE = /\x1b\[[0-9;]*[A-Za-z]/g;
+function stripAnsi3(s) {
+  return s.replace(ANSI_RE, "");
+}
+function truncate3(s, max) {
+  const plain = stripAnsi3(s);
+  if (plain.length <= max) return plain;
+  return plain.slice(0, max - 1) + "\u2026";
+}
+function buildBar(completed, total, active) {
+  const ratio = (completed + (active ? 0.5 : 0)) / total;
+  const filled = Math.min(BAR_WIDTH, Math.round(ratio * BAR_WIDTH));
+  const head = active && filled < BAR_WIDTH ? 1 : 0;
+  const full = export_pc.green("\u2588".repeat(Math.max(0, filled - head)));
+  const tip = head ? export_pc.cyan("\u258C") : "";
+  const empty = export_pc.dim("\u2591".repeat(BAR_WIDTH - filled));
+  const pct = `${Math.round(ratio * 100)}%`.padStart(4);
+  return `${full}${tip}${empty}  ${export_pc.bold(pct)}  ${export_pc.dim(`${completed}/${total}`)}`;
+}
+var LiveRender = class {
+  linesPrinted = 0;
+  cursorHidden = false;
+  start() {
+    if (process.stdout.isTTY) {
+      process.stdout.write("\x1B[?25l");
+      this.cursorHidden = true;
+    }
+  }
+  stop() {
+    if (this.cursorHidden) {
+      process.stdout.write("\x1B[?25h");
+      this.cursorHidden = false;
+    }
+  }
+  /** Replace the live block in place. */
+  render(lines) {
+    if (!process.stdout.isTTY) {
+      for (const line of lines) process.stdout.write(line + "\n");
+      return;
+    }
+    if (this.linesPrinted > 0) {
+      process.stdout.write(`\x1B[${this.linesPrinted}A\r\x1B[J`);
+    }
+    process.stdout.write(lines.join("\n") + "\n");
+    this.linesPrinted = lines.length;
+  }
+  /** Commit the live block as permanent output and start fresh. */
+  commit(lines) {
+    if (process.stdout.isTTY && this.linesPrinted > 0) {
+      process.stdout.write(`\x1B[${this.linesPrinted}A\r\x1B[J`);
+    }
+    for (const line of lines) process.stdout.write(line + "\n");
+    this.linesPrinted = 0;
+  }
+};
+async function runStep(entry, step2, index, total, live) {
+  const cols = Math.max(40, process.stdout.columns ?? 80);
+  const tailMax = Math.max(20, cols - 6);
+  return new Promise((resolve19) => {
+    const child = spawn4(process.execPath, [entry, ...step2.args], {
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: true
+    });
+    const captured = [];
+    let tail = export_pc.dim("starting\u2026");
+    let frame = 0;
+    let done = false;
+    const handleChunk = (buf) => {
+      const text = buf.toString("utf8");
+      captured.push(text);
+      const lines = text.split(/\r?\n/);
+      for (let i = lines.length - 1; i >= 0; i--) {
+        const cleaned = stripAnsi3(lines[i]).trim();
+        if (cleaned.length > 0) {
+          tail = export_pc.dim(truncate3(cleaned, tailMax));
+          break;
+        }
+      }
+    };
+    child.stdout.on("data", handleChunk);
+    child.stderr.on("data", handleChunk);
+    const draw = () => {
+      const spin = export_pc.cyan(SPINNER_FRAMES[frame % SPINNER_FRAMES.length]);
+      const bar = buildBar(index, total, true);
+      const header = `  ${spin}  ${export_pc.cyan(step2.icon)}  ${export_pc.bold(step2.label)}  ${export_pc.dim(`[${index + 1}/${total}]`)}`;
+      live.render([
+        `  ${bar}`,
+        header,
+        `    ${tail}`
+      ]);
+      frame++;
+    };
+    draw();
+    const ticker = setInterval(() => {
+      if (!done) draw();
+    }, 80);
+    child.on("close", (code) => {
+      done = true;
+      clearInterval(ticker);
+      resolve19({ code: code ?? 1, tail: captured });
+    });
+  });
+}
+var gigasyncCommand = new Command("gigasync").description("Chain git sync \u2192 obsidian update \u2192 shard update \u2192 sync (stops on first failure)").addHelpText("after", `
+Runs in order:
+  1. flint git sync   (skipped if no git repo)
+  2. flint obsidian update
+  3. flint shard update
+  4. flint sync
+
+If any step exits non-zero, Gigasync stops and exits with that code.
+`).action(async () => {
+  const entry = process.argv[1];
+  if (!entry) {
+    console.error(export_pc.red("Error: Could not resolve flint entry script (process.argv[1] missing)."));
+    process.exit(1);
+  }
+  const flintPath = await findFlintRoot(process.cwd());
+  if (!flintPath) {
+    console.error(export_pc.red("Error: Not inside a Flint. cd into a Flint and retry."));
+    process.exit(1);
+  }
+  const live = new LiveRender();
+  live.start();
+  const cleanup = () => live.stop();
+  process.on("SIGINT", () => {
+    cleanup();
+    process.exit(130);
+  });
+  process.on("exit", cleanup);
+  const completed = [];
+  for (let i = 0; i < STEPS.length; i++) {
+    const step2 = STEPS[i];
+    if (step2.skipIf) {
+      const reason = await step2.skipIf(flintPath);
+      if (reason) {
+        completed.push(`  ${export_pc.yellow("\u2298")}  ${export_pc.cyan(step2.icon)}  ${step2.label}  ${export_pc.dim(`\u2014 skipped (${reason})`)}`);
+        live.render([
+          `  ${buildBar(i + 1, STEPS.length, false)}`,
+          ...completed
+        ]);
+        await sleep(120);
+        continue;
+      }
+    }
+    const beforeState = step2.before ? await step2.before(flintPath) : void 0;
+    const { code, tail } = await runStep(entry, step2, i, STEPS.length, live);
+    if (code !== 0) {
+      live.commit([
+        `  ${buildBar(i, STEPS.length, false)}`,
+        ...completed,
+        `  ${export_pc.red("\u2717")}  ${export_pc.cyan(step2.icon)}  ${export_pc.bold(step2.label)}  ${export_pc.red(`\u2014 exited ${code}`)}`,
+        export_pc.dim("  \u2500\u2500 output \u2500\u2500")
+      ]);
+      process.stdout.write(tail.join(""));
+      if (!tail.join("").endsWith("\n")) process.stdout.write("\n");
+      live.stop();
+      process.exit(code);
+    }
+    const note = step2.afterNote ? await step2.afterNote(flintPath, beforeState) : null;
+    const noteSuffix = note ? `  ${export_pc.yellow(`(${note})`)}` : "";
+    completed.push(`  ${export_pc.green("\u2713")}  ${export_pc.cyan(step2.icon)}  ${step2.label}${noteSuffix}`);
+    live.render([
+      `  ${buildBar(i + 1, STEPS.length, false)}`,
+      ...completed
+    ]);
+  }
+  live.commit([
+    `  ${buildBar(STEPS.length, STEPS.length, false)}`,
+    ...completed,
+    export_pc.bold(export_pc.green("  \u2713 Gigasync complete."))
+  ]);
+  live.stop();
+});
+
 // src/commands/flint/registry.ts
 init_dist4();
 async function validateEntries(entries) {
@@ -157711,14 +158022,14 @@ var registryCommand = new Command("registry").description("Validate the global f
 
 // src/commands/flint/update.ts
 import { readFileSync as readFileSync4, existsSync as existsSync6 } from "fs";
-import { dirname as dirname10, join as join26 } from "path";
+import { dirname as dirname10, join as join27 } from "path";
 import { fileURLToPath as fileURLToPath4 } from "url";
 import { execSync as execSync3 } from "child_process";
 import https from "https";
 var __dirname4 = dirname10(fileURLToPath4(import.meta.url));
 function readPkgVersion() {
   for (const rel of ["../..", ".."]) {
-    const p = join26(__dirname4, rel, "package.json");
+    const p = join27(__dirname4, rel, "package.json");
     if (existsSync6(p)) {
       return JSON.parse(readFileSync4(p, "utf-8")).version;
     }
@@ -157793,7 +158104,7 @@ var updateCommand = new Command("update").description("Update flint-cli to the l
 
 // src/commands/workspace/workspace.ts
 init_dist4();
-import { join as join27 } from "path";
+import { join as join28 } from "path";
 import * as readline from "readline";
 async function prompt2(question) {
   const rl = readline.createInterface({
@@ -157824,7 +158135,7 @@ var workspaceCommand = new Command("workspace").description("Manage workspace re
 Creating repository ${name}...`));
       await addWorkspaceRepository(flintPath, name, remote);
       await updateGitignore(flintPath);
-      const repoPath = join27(flintPath, "Workspace", "Repos", name);
+      const repoPath = join28(flintPath, "Workspace", "Repos", name);
       console.log(export_pc.green(`
 Created repository: ${export_pc.bold(name)}`));
       console.log(export_pc.dim(`  Remote: ${remote}`));
@@ -157889,7 +158200,7 @@ Cloned repository: ${export_pc.bold(name)}`));
       }
       await removeWorkspaceRepository(flintPath, name);
       await updateGitignore(flintPath);
-      const localStatePath = join27(flintPath, "Workspace", "Repos", name);
+      const localStatePath = join28(flintPath, "Workspace", "Repos", name);
       console.log(export_pc.green(`
 Removed repository: ${export_pc.bold(name)}`));
       console.log(export_pc.dim("  \u2192 Removed from flint.toml"));
@@ -157976,7 +158287,7 @@ Updated repository: ${export_pc.bold(name)}`));
 // src/commands/sources/source.ts
 init_dist4();
 import { stat as stat13 } from "fs/promises";
-import { join as join28, basename as basename6 } from "path";
+import { join as join29, basename as basename6 } from "path";
 import { rm as rm11, readdir as readdir14, mkdir as mkdir15, copyFile as copyFile3 } from "fs/promises";
 import * as readline2 from "readline";
 async function prompt3(question) {
@@ -158009,7 +158320,7 @@ repoCommand.addCommand(
 Cloning ${url} (reference copy)...`));
       await addSourceRepository(flintPath, name, url);
       await updateGitignore(flintPath);
-      const repoPath = join28(flintPath, "Sources", "Repos", name);
+      const repoPath = join29(flintPath, "Sources", "Repos", name);
       console.log(export_pc.green(`
 Added source repository: ${export_pc.bold(name)}`));
       console.log(export_pc.dim(`  URL: ${url}`));
@@ -158045,7 +158356,7 @@ repoCommand.addCommand(
       }
       await removeSourceRepository(flintPath, name);
       await updateGitignore(flintPath);
-      const localStatePath = join28(flintPath, "Sources", "Repos", name);
+      const localStatePath = join29(flintPath, "Sources", "Repos", name);
       console.log(export_pc.green(`
 Removed source repository: ${export_pc.bold(name)}`));
       console.log(export_pc.dim("  \u2192 Removed from flint.toml"));
@@ -158244,14 +158555,14 @@ meshexportCommand.addCommand(
       }
       const { flintName, exportName } = parsed;
       console.log();
-      const sourceDir = join28(flintPath, "Sources", "Flints", `(Flint) ${flintName}`, `(Mesh Export) ${exportName}`);
+      const sourceDir = join29(flintPath, "Sources", "Flints", `(Flint) ${flintName}`, `(Mesh Export) ${exportName}`);
       const removed = await removeSourceBundleFromConfig(flintPath, { source: "flint", name: ref });
       if (!removed) {
         console.error(export_pc.red(`Error: "${ref}" not found in flint.toml [sources].bundles.`));
         process.exit(1);
       }
       console.log(`${export_pc.green("\u2713")} Removed from flint.toml`);
-      const parentDir = join28(flintPath, "Sources", "Flints", `(Flint) ${flintName}`);
+      const parentDir = join29(flintPath, "Sources", "Flints", `(Flint) ${flintName}`);
       try {
         const remaining = await readdir14(parentDir);
         if (remaining.length === 0) {
@@ -158659,7 +158970,7 @@ init_dist4();
 import fs16 from "fs";
 import path20 from "path";
 import crypto2 from "crypto";
-import { spawn as spawn4 } from "child_process";
+import { spawn as spawn5 } from "child_process";
 function getRegistryPath() {
   return path20.join(getConfigDir("lattice"), "registry.json");
 }
@@ -158891,7 +159202,7 @@ var latticeCommand = new Command("lattice").description("Manage lattice connecti
     const entryPoint = path20.join(entry.path, entryFile);
     const cmd = entry.lang === "python" ? "uv" : "node";
     const cmdArgs = entry.lang === "python" ? ["run", "python", entryPoint, fn, ...args] : [entryPoint, fn, ...args];
-    const child = spawn4(cmd, cmdArgs, {
+    const child = spawn5(cmd, cmdArgs, {
       cwd: entry.path,
       env: { ...process.env, ...envLocal },
       stdio: "inherit",
@@ -159020,7 +159331,7 @@ var latticeCommand = new Command("lattice").description("Manage lattice connecti
 // src/commands/outputs/export.ts
 init_dist4();
 import { readFile as readFile13, stat as stat15 } from "fs/promises";
-import { join as join29, basename as basename7 } from "path";
+import { join as join30, basename as basename7 } from "path";
 import { createInterface as createInterface5 } from "readline";
 async function exists3(path30) {
   try {
@@ -159060,8 +159371,8 @@ async function getExportStatus(flintPath) {
   const declarations = await getExportDeclarations(flintPath);
   const results = [];
   for (const manifest of manifests) {
-    const outputDir = join29(flintPath, "Exports", `(Mesh Export) ${manifest.name}`);
-    const manifestJsonPath = join29(outputDir, "_manifest.json");
+    const outputDir = join30(flintPath, "Exports", `(Mesh Export) ${manifest.name}`);
+    const manifestJsonPath = join30(outputDir, "_manifest.json");
     const isBuilt = await exists3(manifestJsonPath);
     let fileCount = 0;
     if (isBuilt) {
@@ -159304,7 +159615,7 @@ var exportCommand = new Command("export").description("Manage exports").addComma
 init_dist4();
 import { randomUUID as randomUUID6 } from "crypto";
 import { copyFile as copyFile4, mkdir as mkdir16, writeFile as writeFile12, unlink as unlink3, stat as stat16 } from "fs/promises";
-import { join as join30, basename as basename8, resolve as resolve17 } from "path";
+import { join as join31, basename as basename8, resolve as resolve17 } from "path";
 async function exists4(path30) {
   try {
     await stat16(path30);
@@ -159373,7 +159684,7 @@ var sendCommand = new Command("send").description("Send files to another Flint's
       process.exit(1);
     }
     const bundleDirName = `(Bundle) ${title}`;
-    const bundleDir = join30(targetPath, "Inbox", bundleDirName);
+    const bundleDir = join31(targetPath, "Inbox", bundleDirName);
     if (await exists4(bundleDir)) {
       console.error(export_pc.red(`Error: Bundle "${title}" already exists in target inbox.`));
       process.exit(1);
@@ -159392,7 +159703,7 @@ var sendCommand = new Command("send").description("Send files to another Flint's
     } catch {
     }
     const bundleNoteFileName = `(Inbox) ${bundleDirName}.md`;
-    const bundleNotePath = join30(bundleDir, bundleNoteFileName);
+    const bundleNotePath = join31(bundleDir, bundleNoteFileName);
     const moveList = moveFiles.length > 0 ? moveFiles.map((f) => `  - "${f.fileName}"`).join("\n") : "";
     const copyList = copyFiles.length > 0 ? copyFiles.map((f) => `  - "${f.fileName}"`).join("\n") : "";
     let frontmatter = `---
@@ -159421,7 +159732,7 @@ ${instructions}
     console.log(`  ${export_pc.green("+")} ${bundleNoteFileName}`);
     for (const file of allFiles) {
       const destFileName = `(Inbox) ${bundleDirName} . ${file.fileName}`;
-      const destPath = join30(bundleDir, destFileName);
+      const destPath = join31(bundleDir, destFileName);
       await copyFile4(file.sourcePath, destPath);
       const isCopy = copyFiles.includes(file);
       const label = isCopy ? export_pc.dim(" (copy)") : "";
@@ -159457,8 +159768,8 @@ ${instructions}
 
 // src/commands/config/shard.ts
 init_dist2();
-import { spawn as spawn5 } from "child_process";
-import { join as join31 } from "path";
+import { spawn as spawn6 } from "child_process";
+import { join as join35 } from "path";
 import { existsSync as existsSync7 } from "fs";
 import { readFile as readFile14 } from "fs/promises";
 init_dist4();
@@ -159617,7 +159928,7 @@ Shard not found: "${shorthand}"`));
       if (counts.length > 0) {
         console.log(`  Contents    ${counts.join(", ")}`);
       }
-      const shardPath = join31(flintPath, "Shards", detail2.folderName);
+      const shardPath = join35(flintPath, "Shards", detail2.folderName);
       const manifestResult = await readShardManifest(shardPath);
       const manifest = manifestResult?.manifest;
       if (manifest?.dependencies?.length) {
@@ -159659,12 +159970,12 @@ Shard not found: "${shorthand}"`));
       return;
     }
     if (action === "pull") {
-      const { execSync: execSync6 } = await import("child_process");
+      const { execSync: execSync5 } = await import("child_process");
       const resolved = await resolveDevShard(flintPath, shorthand);
       if (!resolved) process.exit(1);
       const { info: match2 } = resolved;
-      const shardPath = join31(flintPath, "Shards", match2.folderName);
-      const gitDir = join31(shardPath, ".git");
+      const shardPath = join35(flintPath, "Shards", match2.folderName);
+      const gitDir = join35(shardPath, ".git");
       if (!existsSync7(gitDir)) {
         console.error(export_pc.red(`
 "${match2.folderName}" has no git repo.`));
@@ -159676,7 +159987,7 @@ Shard not found: "${shorthand}"`));
 Pulling ${match2.folderName}...
 `));
       try {
-        execSync6("git pull", { cwd: shardPath, stdio: "inherit" });
+        execSync5("git pull", { cwd: shardPath, stdio: "inherit" });
         console.log(export_pc.green(`
   \u2713 Pulled ${match2.folderName}`));
       } catch {
@@ -159714,7 +160025,7 @@ Pulling ${match2.folderName}...
 Shard not found: "${shorthand}"`));
         process.exit(1);
       }
-      const shardDir = join31(flintPath, "Shards", detail2.folderName);
+      const shardDir = join35(flintPath, "Shards", detail2.folderName);
       if (!existsSync7(shardDir)) {
         console.error(export_pc.red(`
 Shard not installed: "${shorthand}"`));
@@ -159725,7 +160036,7 @@ Shard not installed: "${shorthand}"`));
       const execIdx = rawArgs.indexOf("exec");
       const execArgs = execIdx >= 0 ? rawArgs.slice(execIdx + 1) : [];
       const fullCmd = execArgs.join(" ");
-      const child = spawn5(fullCmd, [], {
+      const child = spawn6(fullCmd, [], {
         cwd: shardDir,
         stdio: "inherit",
         shell: true,
@@ -160392,7 +160703,7 @@ Created ${export_pc.bold(result.name)}`));
 ).addCommand(
   new Command("dev").description("Promote a Dev Local shard to Dev Remote \u2014 git init, set remote, commit, push").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, options3) => {
     try {
-      const { execSync: execSync6 } = await import("child_process");
+      const { execSync: execSync5 } = await import("child_process");
       const { rename: rename11 } = await import("fs/promises");
       const flintPath = await resolveFlint(options3.path);
       const resolved = await resolveDevShard(flintPath, name);
@@ -160417,19 +160728,19 @@ Invalid GitHub remote: "${url}"`));
         console.log();
         return;
       }
-      const shardPath = join31(flintPath, "Shards", match2.folderName);
+      const shardPath = join35(flintPath, "Shards", match2.folderName);
       console.log(export_pc.bold(`
 Promoting ${match2.folderName} to Dev Remote...
 `));
-      execSync6("git init", { cwd: shardPath, stdio: "pipe" });
-      execSync6(`git remote add origin "${url}"`, { cwd: shardPath, stdio: "pipe" });
-      execSync6("git branch -M main", { cwd: shardPath, stdio: "pipe" });
-      execSync6("git add -A", { cwd: shardPath, stdio: "pipe" });
-      execSync6('git commit -m "initial commit"', { cwd: shardPath, stdio: "pipe" });
-      execSync6("git push -u origin main", { cwd: shardPath, stdio: "inherit" });
+      execSync5("git init", { cwd: shardPath, stdio: "pipe" });
+      execSync5(`git remote add origin "${url}"`, { cwd: shardPath, stdio: "pipe" });
+      execSync5("git branch -M main", { cwd: shardPath, stdio: "pipe" });
+      execSync5("git add -A", { cwd: shardPath, stdio: "pipe" });
+      execSync5('git commit -m "initial commit"', { cwd: shardPath, stdio: "pipe" });
+      execSync5("git push -u origin main", { cwd: shardPath, stdio: "inherit" });
       const baseName = match2.folderName.replace(/^\(Dev Local\)\s*/, "");
       const devFolderName = `(Dev Remote) ${baseName}`;
-      const devPath = join31(flintPath, "Shards", devFolderName);
+      const devPath = join35(flintPath, "Shards", devFolderName);
       if (existsSync7(devPath)) {
         console.error(export_pc.red(`
 Cannot promote: "${devFolderName}" already exists.`));
@@ -160461,7 +160772,7 @@ ${export_pc.bold(devFolderName)} promoted to Dev Remote`));
   new Command("clone").description("Clone a remote shard for development (creates (Dev Remote) folder, does NOT install)").argument("<source>", "Source identifier (e.g. owner/repo)").option("-p, --path <dir>", "Path to flint").action(async (rawSource, options3) => {
     try {
       const flintPath = await resolveFlint(options3.path);
-      const { execSync: execSync6 } = await import("child_process");
+      const { execSync: execSync5 } = await import("child_process");
       let source = rawSource;
       if (!rawSource.includes("/") && !rawSource.startsWith("github:")) {
         source = `${NUU_SHARD_PREFIX}${rawSource}`;
@@ -160481,7 +160792,7 @@ Resolving ${source}...`));
       const resolved = await resolveShardSource(parsed, flintPath);
       try {
         const devFolderName = `(Dev Remote) ${resolved.manifest.name}`;
-        const devPath = join31(flintPath, "Shards", devFolderName);
+        const devPath = join35(flintPath, "Shards", devFolderName);
         if (existsSync7(devPath)) {
           console.error(export_pc.red(`
 Dev folder already exists: Shards/${devFolderName}`));
@@ -160490,7 +160801,7 @@ Dev folder already exists: Shards/${devFolderName}`));
         }
         const ghSource = parsed;
         console.log(export_pc.dim(`Cloning into Shards/${devFolderName}...`));
-        execSync6(
+        execSync5(
           `git clone "https://github.com/${ghSource.owner}/${ghSource.repo}.git" "${devPath}"`,
           { stdio: "pipe", timeout: 6e4 }
         );
@@ -160590,7 +160901,7 @@ Shard not found: "${identifier}"`));
       if (counts.length > 0) {
         console.log(`  Contents    ${counts.join(", ")}`);
       }
-      const shardPath = join31(flintPath, "Shards", detail2.folderName);
+      const shardPath = join35(flintPath, "Shards", detail2.folderName);
       const manifestResult = await readShardManifest(shardPath);
       const manifest = manifestResult?.manifest;
       if (manifest?.dependencies?.length) {
@@ -160642,7 +160953,7 @@ Shard "${identifier}" not found.
 `));
         process.exit(1);
       }
-      const shardPath = join31(flintPath, "Shards", info.folderName);
+      const shardPath = join35(flintPath, "Shards", info.folderName);
       const manifestRead = await readShardManifest(shardPath);
       const manifest = manifestRead?.manifest;
       if (!manifest) {
@@ -160893,13 +161204,13 @@ Pending shard migrations for ${result.shard.folderName}:
 ).addCommand(
   new Command("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, options3) => {
     try {
-      const { execSync: execSync6 } = await import("child_process");
+      const { execSync: execSync5 } = await import("child_process");
       const flintPath = await resolveFlint(options3.path);
       const resolved = await resolveDevShard(flintPath, name);
       if (!resolved) return;
       const { info: match2 } = resolved;
-      const shardPath = join31(flintPath, "Shards", match2.folderName);
-      const gitDir = join31(shardPath, ".git");
+      const shardPath = join35(flintPath, "Shards", match2.folderName);
+      const gitDir = join35(shardPath, ".git");
       if (!existsSync7(gitDir)) {
         console.error(export_pc.red(`
 "${match2.folderName}" has no git repo. Initialize one first:`));
@@ -160907,15 +161218,15 @@ Pending shard migrations for ${result.shard.folderName}:
         console.log();
         return;
       }
-      const status = execSync6("git status --porcelain", { cwd: shardPath, encoding: "utf-8" }).trim();
+      const status = execSync5("git status --porcelain", { cwd: shardPath, encoding: "utf-8" }).trim();
       if (!status) {
         try {
-          const unpushed = execSync6("git log @{u}..HEAD --oneline", { cwd: shardPath, encoding: "utf-8" }).trim();
+          const unpushed = execSync5("git log @{u}..HEAD --oneline", { cwd: shardPath, encoding: "utf-8" }).trim();
           if (unpushed) {
             console.log(export_pc.bold(`
 Pushing ${match2.folderName}...
 `));
-            execSync6("git push", { cwd: shardPath, stdio: "inherit" });
+            execSync5("git push", { cwd: shardPath, stdio: "inherit" });
             console.log(export_pc.green(`
   Pushed unpushed commits.`));
             console.log();
@@ -160938,7 +161249,7 @@ Invalid bump level "${level}". Use: patch, minor, or major.`));
           return;
         }
         const { readFile: readFile18, writeFile: writeFile15 } = await import("fs/promises");
-        const yamlPath = join31(shardPath, "shard.yaml");
+        const yamlPath = join35(shardPath, "shard.yaml");
         const yamlContent = await readFile18(yamlPath, "utf-8");
         const versionMatch = yamlContent.match(/^version:\s*"?(\d+)\.(\d+)\.(\d+)"?/m);
         if (!versionMatch) {
@@ -160959,13 +161270,13 @@ Could not parse version from shard.yaml.`));
       console.log(export_pc.bold(`
 Pushing ${match2.folderName}...
 `));
-      execSync6("git add -A", { cwd: shardPath, stdio: "pipe" });
-      execSync6(`git commit -m "${message.replace(/"/g, '\\"')}"`, { cwd: shardPath, stdio: "pipe" });
+      execSync5("git add -A", { cwd: shardPath, stdio: "pipe" });
+      execSync5(`git commit -m "${message.replace(/"/g, '\\"')}"`, { cwd: shardPath, stdio: "pipe" });
       try {
-        execSync6("git push", { cwd: shardPath, stdio: "inherit" });
+        execSync5("git push", { cwd: shardPath, stdio: "inherit" });
       } catch {
-        const branch = execSync6("git branch --show-current", { cwd: shardPath, encoding: "utf-8" }).trim();
-        execSync6(`git push -u origin ${branch}`, { cwd: shardPath, stdio: "inherit" });
+        const branch = execSync5("git branch --show-current", { cwd: shardPath, encoding: "utf-8" }).trim();
+        execSync5(`git push -u origin ${branch}`, { cwd: shardPath, stdio: "inherit" });
       }
       console.log(export_pc.green(`
   ${export_pc.bold(match2.folderName)} pushed.`));
@@ -160989,7 +161300,7 @@ Pushing ${match2.folderName}...
         const resolved = await resolveDevShard(flintPath, name);
         if (!resolved) process.exit(1);
         const { info: match2 } = resolved;
-        const shardPath = join31(flintPath, "Shards", match2.folderName);
+        const shardPath = join35(flintPath, "Shards", match2.folderName);
         const detail2 = await getShardInfo(flintPath, match2.folderName);
         if (!detail2) {
           console.error(export_pc.red(`
@@ -161007,10 +161318,10 @@ Cannot read shard info for "${name}".`));
         }
         if (!repo) {
           try {
-            const { execSync: execSync6 } = await import("child_process");
-            const gitDir = join31(shardPath, ".git");
+            const { execSync: execSync5 } = await import("child_process");
+            const gitDir = join35(shardPath, ".git");
             if (existsSync7(gitDir)) {
-              const remoteUrl = execSync6("git remote get-url origin", { cwd: shardPath, encoding: "utf-8" }).trim();
+              const remoteUrl = execSync5("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];
@@ -161027,7 +161338,7 @@ Cannot determine repo for "${name}".`));
           process.exit(1);
         }
         let readme;
-        const readmePath = join31(shardPath, "README.md");
+        const readmePath = join35(shardPath, "README.md");
         if (existsSync7(readmePath)) {
           readme = await readFile14(readmePath, "utf-8");
         }
@@ -161224,7 +161535,7 @@ Failed to fetch published shards: ${msg}`));
       const resolved = await resolveDevShard(flintPath, name);
       if (!resolved) process.exit(1);
       const { info: shard } = resolved;
-      const shardPath = join31(flintPath, "Shards", shard.folderName);
+      const shardPath = join35(flintPath, "Shards", shard.folderName);
       const remoteUrl = await getRemoteUrl(shardPath);
       if (!remoteUrl) {
         console.error(export_pc.red(`
@@ -161568,21 +161879,53 @@ function getNestedValue(obj, key) {
 // src/commands/config/obsidian.ts
 init_dist4();
 import { execSync as execSync4, spawnSync } from "child_process";
-import { join as join35 } from "path";
+import { join as join36 } from "path";
 import { stat as stat17, rm as rm12 } from "fs/promises";
-import { platform as platform6 } from "os";
+import { platform as platform5 } from "os";
+import { request as httpRequest } from "http";
 function getExpectedRepoUrl() {
-  return platform6() === "win32" ? OBSIDIAN_WINDOWS_REPO_URL : OBSIDIAN_REPO_URL;
+  return platform5() === "win32" ? OBSIDIAN_WINDOWS_REPO_URL : OBSIDIAN_REPO_URL;
+}
+function postReload(port) {
+  return new Promise((resolve19, reject) => {
+    const req = httpRequest({
+      hostname: "127.0.0.1",
+      port,
+      method: "POST",
+      path: "/app/reload",
+      timeout: 2e3
+    }, (res) => {
+      res.resume();
+      res.on("end", () => resolve19());
+    });
+    req.on("error", reject);
+    req.on("timeout", () => req.destroy(new Error("timeout")));
+    req.end();
+  });
+}
+async function maybeReloadObsidian(flintPath) {
+  const plugin = await findLivePluginForVault(flintPath);
+  if (!plugin) {
+    console.log(export_pc.dim("Obsidian not open for this vault \u2014 skipping reload."));
+    return;
+  }
+  try {
+    await postReload(plugin.port);
+    console.log(export_pc.green("Reloaded Obsidian."));
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.log(export_pc.dim(`Could not reach Obsidian plugin (${message}) \u2014 skipping reload.`));
+  }
 }
 var obsidianCommand = new Command("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 () => {
+obsidianCommand.command("update").description("Force pull latest .obsidian from remote (discards local changes)").option("--no-reload", "Skip reloading the running Obsidian app after the pull").action(async (cmdOptions) => {
   const options3 = obsidianCommand.opts();
   const flintPath = options3.path || await findFlintRoot(process.cwd());
   if (!flintPath) {
     console.error(export_pc.red("Error: Not inside a Flint."));
     process.exit(1);
   }
-  const obsidianDir = join35(flintPath, ".obsidian");
+  const obsidianDir = join36(flintPath, ".obsidian");
   try {
     await stat17(obsidianDir);
   } catch {
@@ -161609,6 +161952,9 @@ obsidianCommand.command("update").description("Force pull latest .obsidian from
     console.error(export_pc.red(`Error updating .obsidian: ${message}`));
     process.exit(1);
   }
+  if (cmdOptions.reload !== false) {
+    await maybeReloadObsidian(flintPath);
+  }
 });
 if (isFeatureEnabled(FEATURES, "obsidian.push", resolveRuntimeSync({ cliname: "flint" }))) {
   obsidianCommand.command("push").description(`Commit all changes and push to remote ${export_pc.dim("[dev]")}`).option("-m, --message <msg>", "Commit message", "Update obsidian config").action(async (cmdOptions) => {
@@ -161618,7 +161964,7 @@ if (isFeatureEnabled(FEATURES, "obsidian.push", resolveRuntimeSync({ cliname: "f
       console.error(export_pc.red("Error: Not inside a Flint."));
       process.exit(1);
     }
-    const obsidianDir = join35(flintPath, ".obsidian");
+    const obsidianDir = join36(flintPath, ".obsidian");
     try {
       await stat17(obsidianDir);
     } catch {
@@ -161655,7 +162001,7 @@ obsidianCommand.command("reset").description("Delete and re-clone .obsidian from
     console.error(export_pc.red("Error: Not inside a Flint."));
     process.exit(1);
   }
-  const obsidianDir = join35(flintPath, ".obsidian");
+  const obsidianDir = join36(flintPath, ".obsidian");
   let exists7 = false;
   try {
     await stat17(obsidianDir);
@@ -162132,15 +162478,13 @@ plateCommand.command("info").description("Show Plate details").argument("<name>"
 
 // src/commands/agent/orbh.ts
 init_dist4();
-import { execSync as execSync5, spawnSync as spawnSync7 } from "child_process";
-import { mkdirSync as mkdirSync4, readFileSync as readFileSync15, writeFileSync as writeFileSync2 } from "fs";
-import { join as join39 } from "path";
-import { createInterface as createInterface7 } from "readline";
+import { spawnSync as spawnSync7 } from "child_process";
+import { join as join40 } from "path";
 
 // ../orbh-cli/src/index.ts
-import { spawn as spawn8, spawnSync as spawnSync6 } from "child_process";
-import { existsSync as existsSync17, readFileSync as readFileSync14 } from "fs";
-import { dirname as dirname12, join as join38, resolve as resolvePath3 } from "path";
+import { spawn as spawn9, spawnSync as spawnSync6 } from "child_process";
+import { existsSync as existsSync18, readFileSync as readFileSync15 } from "fs";
+import { dirname as dirname12, join as join39, resolve as resolvePath3 } from "path";
 import { fileURLToPath as fileURLToPath6, pathToFileURL } from "url";
 
 // ../../packages/orbh/dist/index.js
@@ -162151,7 +162495,7 @@ import { closeSync, existsSync as existsSync42, openSync, readSync, statSync as
 import { existsSync as existsSync52, readFileSync as readFileSync42, unwatchFile as unwatchFile2, watch as watch2, watchFile as watchFile2 } from "fs";
 import { spawnSync as spawnSync2 } from "child_process";
 import { existsSync as existsSync72, readFileSync as readFileSync6 } from "fs";
-import { dirname as dirname24, join as join36 } from "path";
+import { dirname as dirname24, join as join37 } from "path";
 import { spawnSync as spawnSync22 } from "child_process";
 import { existsSync as existsSync8 } from "fs";
 import { homedir as homedir8 } from "os";
@@ -162159,7 +162503,7 @@ import { join as join45 } from "path";
 import { existsSync as existsSync9 } from "fs";
 import { join as join53 } from "path";
 import { homedir as homedir23 } from "os";
-import { spawn as spawn6 } from "child_process";
+import { spawn as spawn7 } from "child_process";
 import { createInterface as createInterface6 } from "readline";
 import { readdirSync as readdirSync3, readFileSync as readFileSync7 } from "fs";
 import { existsSync as existsSync10 } from "fs";
@@ -162172,30 +162516,35 @@ import { existsSync as existsSync12, readdirSync as readdirSync5, readFileSync a
 import { spawnSync as spawnSync3 } from "child_process";
 import { homedir as homedir52 } from "os";
 import { basename as basename23, join as join83 } from "path";
-import { existsSync as existsSync13, readFileSync as readFileSync10, statSync as statSync5, unwatchFile as unwatchFile3, watchFile as watchFile3 } from "fs";
-import { existsSync as existsSync14, mkdirSync as mkdirSync2, readdirSync as readdirSync6, readFileSync as readFileSync11, realpathSync, statSync as statSync6 } from "fs";
+import { spawn as spawn23 } from "child_process";
+import { existsSync as existsSync13, readdirSync as readdirSync6, readFileSync as readFileSync10, statSync as statSync5 } from "fs";
 import { homedir as homedir62 } from "os";
 import { basename as basename33, join as join93 } from "path";
+import { existsSync as existsSync14, readFileSync as readFileSync11, statSync as statSync6, unwatchFile as unwatchFile3, watchFile as watchFile3 } from "fs";
+import { existsSync as existsSync15, mkdirSync as mkdirSync2, readdirSync as readdirSync7, readFileSync as readFileSync12, realpathSync, statSync as statSync7 } from "fs";
+import { homedir as homedir72 } from "os";
+import { basename as basename43, join as join103 } from "path";
 import { randomUUID as randomUUID7 } from "crypto";
 import { EventEmitter } from "events";
 import { randomUUID as randomUUID23 } from "crypto";
 import { mkdirSync as mkdirSync3, readdirSync, readFileSync as readFileSync5, renameSync, writeFileSync } from "fs";
-import { existsSync as existsSync15 } from "fs";
-import { join as join37 } from "path";
+import { existsSync as existsSync16 } from "fs";
+import { join as join38 } from "path";
 import { randomUUID as randomUUID33 } from "crypto";
 init_dist3();
 import { watch as watch3 } from "fs";
 import { access as access7 } from "fs/promises";
 import path21 from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
-import { spawn as spawn32, spawnSync as spawnSync5 } from "child_process";
-import { spawn as spawn23, spawnSync as spawnSync4 } from "child_process";
-import { createWriteStream, existsSync as existsSync152, readdirSync as readdirSync7, readFileSync as readFileSync12, renameSync as renameSync2 } from "fs";
-import { join as join103 } from "path";
-import { homedir as homedir72 } from "os";
-import { existsSync as existsSync16, readFileSync as readFileSync13 } from "fs";
-import { homedir as homedir82 } from "os";
+import { spawn as spawn42, spawnSync as spawnSync5 } from "child_process";
+import { spawn as spawn32, spawnSync as spawnSync4 } from "child_process";
+import { createWriteStream, existsSync as existsSync162, readdirSync as readdirSync8, readFileSync as readFileSync13, renameSync as renameSync2 } from "fs";
 import { join as join113 } from "path";
+import { homedir as homedir82 } from "os";
+import { existsSync as existsSync17, readFileSync as readFileSync14 } from "fs";
+import { homedir as homedir9 } from "os";
+import { join as join123 } from "path";
+import { EventEmitter as EventEmitter2 } from "events";
 var __defProp3 = Object.defineProperty;
 var __getOwnPropNames3 = Object.getOwnPropertyNames;
 var __esm2 = (fn, res) => function __init() {
@@ -164199,7 +164548,7 @@ function resolveCommand2(name) {
     const matches = [...content.matchAll(/%(?:~dp0|dp0%)\\([^"%\r\n]+\.m?[jc]?[jt]s)/gi)];
     const last = matches.length > 0 ? matches[matches.length - 1] : void 0;
     if (last && last[1]) {
-      const scriptPath = join36(dirname24(resolved), last[1]);
+      const scriptPath = join37(dirname24(resolved), last[1]);
       if (existsSync72(scriptPath)) {
         return { cmd: process.execPath, prependArgs: [scriptPath] };
       }
@@ -164257,6 +164606,10 @@ function parseOpencodeVersion(output) {
   const match2 = output.match(/\bopencode\s+v?(\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?)\b/i);
   return match2?.[1] ?? parseSemver(output);
 }
+function parseGrokVersion(output) {
+  const match2 = output.match(/\bgrok\s+v?(\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?)\b/i);
+  return match2?.[1] ?? parseSemver(output);
+}
 function resolveUserHome() {
   return process.env.HOME || homedir8();
 }
@@ -164351,6 +164704,7 @@ var init_executable = __esm2({
       codex: parseCodexVersion,
       droid: parseDroidVersion,
       gemini: parseGeminiVersion,
+      grok: parseGrokVersion,
       opencode: parseOpencodeVersion
     };
   }
@@ -164584,7 +164938,7 @@ async function bootstrapCodexSession(cwd, initPrompt, options3 = {}) {
     const start = async () => {
       const executable = await getExecutable("codex");
       const spawnCmd = executable.resolvedCommand.cmd;
-      const proc = spawn6(spawnCmd, [...executable.resolvedCommand.prependArgs, ...buildCodexAppServerArgs(options3)], {
+      const proc = spawn7(spawnCmd, [...executable.resolvedCommand.prependArgs, ...buildCodexAppServerArgs(options3)], {
         stdio: ["pipe", "pipe", "pipe"],
         cwd,
         env: options3.env ? { ...process.env, ...options3.env } : process.env,
@@ -164594,48 +164948,40 @@ async function bootstrapCodexSession(cwd, initPrompt, options3 = {}) {
       const send = (message) => proc.stdin.write(`${JSON.stringify(message)}
 `);
       let threadId = null;
-      let sessionPath = null;
       const timeout = setTimeout(() => {
         proc.kill();
         reject(new Error("Timeout waiting for Codex session"));
-      }, 3e4);
+      }, 15e3);
       const cleanup = () => {
         clearTimeout(timeout);
         rl.close();
       };
-      let pollInterval = null;
-      const startPolling = () => {
-        pollInterval = setInterval(() => {
-          if (sessionPath && existsSync10(sessionPath)) {
-            if (pollInterval) {
-              clearInterval(pollInterval);
-            }
-            send({ method: "turn/interrupt", id: 4, params: { threadId } });
-            setTimeout(() => {
-              cleanup();
-              proc.kill();
-              resolve19(threadId);
-            }, 500);
-          }
-        }, 200);
-      };
       rl.on("line", (line) => {
         try {
           const message = JSON.parse(line);
           if (message.id === 2 && message.result?.thread?.id) {
             threadId = message.result.thread.id;
-            sessionPath = message.result.thread.path ?? null;
             send({
-              method: "turn/start",
+              method: "thread/inject_items",
               id: 3,
               params: {
                 threadId,
-                input: [{ type: "text", text: initPrompt }]
+                items: [
+                  {
+                    type: "message",
+                    role: "user",
+                    content: [{ type: "input_text", text: initPrompt }]
+                  }
+                ]
               }
             });
+            return;
           }
-          if (message.id === 3 && message.result?.turn) {
-            startPolling();
+          if (message.id === 3 && message.result) {
+            cleanup();
+            proc.kill();
+            resolve19(threadId);
+            return;
           }
           if (message.error && (message.id ?? 0) <= 3) {
             cleanup();
@@ -165219,6 +165565,376 @@ var init_gemini2 = __esm2({
     GEMINI_COMMAND = "gemini";
   }
 });
+function createGrokMapperContext(options3) {
+  return {
+    toolIdMap: options3?.toolIdMap ?? /* @__PURE__ */ new Map(),
+    transcriptPath: options3?.transcriptPath,
+    turnIndex: 0
+  };
+}
+function isRecord7(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isContentBlockArray(value) {
+  return Array.isArray(value) && value.every((item) => isRecord7(item));
+}
+function stringifyContent3(value) {
+  if (typeof value === "string") return value;
+  if (Array.isArray(value)) return value.map((item) => stringifyContent3(item)).join("\n");
+  if (isRecord7(value)) {
+    if (typeof value.text === "string") return value.text;
+    if (typeof value.content === "string") return value.content;
+    return JSON.stringify(value);
+  }
+  if (value === null || value === void 0) return "";
+  return String(value);
+}
+function syntheticTimestamp(context) {
+  const ms = context.turnIndex;
+  context.turnIndex += 1;
+  return new Date(ms).toISOString();
+}
+function entryTimestamp(entry, context) {
+  if (typeof entry.timestamp === "string") return entry.timestamp;
+  if (typeof entry.timestamp === "number" && Number.isFinite(entry.timestamp)) {
+    return new Date(entry.timestamp).toISOString();
+  }
+  return syntheticTimestamp(context);
+}
+function mapUserEntry2(entry, context) {
+  const content = entry.content;
+  const timestamp = entryTimestamp(entry, context);
+  if (typeof content === "string") {
+    if (content.length === 0) return [];
+    return [{ type: "message", role: "human", text: content, timestamp }];
+  }
+  if (!isContentBlockArray(content)) return [];
+  const mapped = [];
+  for (const block3 of content) {
+    if (block3.type === "text" && typeof block3.text === "string") {
+      if (block3.text.length === 0) continue;
+      mapped.push({ type: "message", role: "human", text: block3.text, timestamp });
+      continue;
+    }
+    if (block3.type === "tool_result" && typeof block3.tool_use_id === "string") {
+      const toolId = block3.tool_use_id;
+      mapped.push({
+        type: "tool-result",
+        id: toolId,
+        tool: context.toolIdMap.get(toolId) ?? "unknown",
+        output: stringifyContent3(block3.content),
+        error: block3.is_error === true,
+        timestamp
+      });
+    }
+  }
+  return mapped;
+}
+function mapAssistantEntry2(entry, context) {
+  const content = entry.content;
+  const timestamp = entryTimestamp(entry, context);
+  if (typeof content === "string") {
+    if (content.length === 0) return [];
+    return [{ type: "message", role: "agent", text: content, timestamp }];
+  }
+  if (!isContentBlockArray(content)) return [];
+  const mapped = [];
+  for (const block3 of content) {
+    if (block3.type === "text" && typeof block3.text === "string") {
+      if (block3.text.length === 0) continue;
+      mapped.push({ type: "message", role: "agent", text: block3.text, timestamp });
+      continue;
+    }
+    if (block3.type === "thinking" && typeof block3.text === "string") {
+      if (block3.text.length === 0) continue;
+      mapped.push({ type: "thinking", text: block3.text, timestamp });
+      continue;
+    }
+    if (block3.type === "tool_use" && typeof block3.id === "string" && typeof block3.name === "string") {
+      context.toolIdMap.set(block3.id, block3.name);
+      mapped.push({
+        type: "tool-call",
+        id: block3.id,
+        tool: block3.name,
+        input: isRecord7(block3.input) ? block3.input : {},
+        timestamp
+      });
+    }
+  }
+  return mapped;
+}
+function buildGrokToolIdMap(entries) {
+  const toolIdMap = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    if (entry.type !== "assistant") continue;
+    if (!isContentBlockArray(entry.content)) continue;
+    for (const block3 of entry.content) {
+      if (block3.type === "tool_use" && typeof block3.id === "string" && typeof block3.name === "string") {
+        toolIdMap.set(block3.id, block3.name);
+      }
+    }
+  }
+  return toolIdMap;
+}
+function mapGrokEntry(entry, context) {
+  switch (entry.type) {
+    case "user":
+      return mapUserEntry2(entry, context);
+    case "assistant":
+      return mapAssistantEntry2(entry, context);
+    case "system":
+    default:
+      return [];
+  }
+}
+function parseGrokTranscript(content, options3) {
+  const rawEntries = content.split("\n").map((line) => line.trim()).filter((line) => line.length > 0).map((line) => {
+    try {
+      return JSON.parse(line);
+    } catch {
+      return null;
+    }
+  }).filter((entry) => entry !== null);
+  const context = createGrokMapperContext({
+    toolIdMap: buildGrokToolIdMap(rawEntries),
+    transcriptPath: options3?.transcriptPath
+  });
+  return rawEntries.flatMap((entry) => mapGrokEntry(entry, context));
+}
+var init_grok = __esm2({
+  "src/mappers/grok.ts"() {
+    "use strict";
+  }
+});
+function encodeGrokCwd(cwd) {
+  const trimmed = cwd.replace(/[\\/]+$/, "");
+  return encodeURIComponent(trimmed);
+}
+function getGrokSessionsRoot() {
+  return join93(homedir62(), ".grok", "sessions");
+}
+function buildScopedSessionDir(cwd) {
+  return join93(getGrokSessionsRoot(), encodeGrokCwd(cwd));
+}
+function buildTranscriptPath2(cwd, nativeSessionId) {
+  return join93(buildScopedSessionDir(cwd), nativeSessionId, GROK_TRANSCRIPT_FILE);
+}
+async function bootstrapGrokSession(cwd, initPrompt, options3 = {}) {
+  const executable = await getExecutable("grok");
+  if (!executable.available) {
+    throw new Error("Grok CLI is not available on PATH.");
+  }
+  const args = [
+    ...executable.resolvedCommand.prependArgs,
+    "-p",
+    initPrompt,
+    "--output-format",
+    "json",
+    "--always-approve",
+    "--cwd",
+    cwd
+  ];
+  if (options3.model) {
+    args.push("--model", options3.model);
+  }
+  if (options3.extraArgs) {
+    args.push(...options3.extraArgs);
+  }
+  return new Promise((resolve19, reject) => {
+    const proc = spawn23(executable.resolvedCommand.cmd, args, {
+      stdio: ["ignore", "pipe", "pipe"],
+      cwd,
+      env: options3.env ? { ...process.env, ...options3.env } : process.env,
+      windowsHide: true
+    });
+    let stdout = "";
+    let stderr = "";
+    proc.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    proc.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    const timeoutMs = options3.timeoutMs ?? 5 * 6e4;
+    const timer = setTimeout(() => {
+      proc.kill("SIGKILL");
+      reject(new Error(`Timed out bootstrapping Grok session after ${timeoutMs}ms`));
+    }, timeoutMs);
+    proc.on("error", (error3) => {
+      clearTimeout(timer);
+      reject(error3);
+    });
+    proc.on("close", (code) => {
+      clearTimeout(timer);
+      if (code !== 0) {
+        reject(new Error(`Grok bootstrap exited ${code}: ${stderr.trim() || stdout.trim()}`));
+        return;
+      }
+      const sessionId = extractGrokSessionId(stdout);
+      if (!sessionId) {
+        reject(new Error(`Grok bootstrap completed but no sessionId in output: ${stdout.slice(-400)}`));
+        return;
+      }
+      resolve19(sessionId);
+    });
+  });
+}
+function extractGrokSessionId(stdout) {
+  const trimmed = stdout.trim();
+  if (trimmed.length === 0) return null;
+  const tryParse = (text) => {
+    try {
+      const parsed = JSON.parse(text);
+      const id = typeof parsed.sessionId === "string" ? parsed.sessionId : typeof parsed.session_id === "string" ? parsed.session_id : null;
+      return id;
+    } catch {
+      return null;
+    }
+  };
+  const whole = tryParse(trimmed);
+  if (whole) return whole;
+  for (const line of trimmed.split(/\r?\n/).reverse()) {
+    const candidate = line.trim();
+    if (!candidate.startsWith("{")) continue;
+    const id = tryParse(candidate);
+    if (id) return id;
+  }
+  return null;
+}
+function createGrokHarness() {
+  return {
+    name: "grok",
+    command: GROK_COMMAND,
+    capabilities: {
+      headless: true,
+      interactive: true,
+      preassignSessionId: false,
+      maxTurns: true,
+      budgetLimit: false,
+      toolHooks: false,
+      subagentVisibility: true,
+      structuredOutput: true,
+      permissionBypass: true
+    },
+    applyConfig(config) {
+      const base = applyDefaultConfig(config);
+      const extraArgs = [...base.extraArgs ?? []];
+      if (typeof config.effort === "string" && config.effort.length > 0) {
+        extraArgs.push("--effort", config.effort);
+      }
+      if (typeof config.reasoningEffort === "string" && config.reasoningEffort.length > 0) {
+        extraArgs.push("--reasoning-effort", config.reasoningEffort);
+      }
+      const env3 = { ...base.env ?? {}, ...normalizeProfileEnv(config.env) };
+      const result = {
+        ...extraArgs.length > 0 ? { extraArgs } : {},
+        ...Object.keys(env3).length > 0 ? { env: env3 } : {}
+      };
+      return appendProfileArgs(result, config);
+    },
+    buildSpawnArgs(config) {
+      const args = [
+        "-p",
+        config.prompt,
+        "--output-format",
+        "streaming-json",
+        "--always-approve",
+        "--cwd",
+        config.cwd
+      ];
+      if (typeof config.maxTurns === "number") {
+        args.push("--max-turns", String(config.maxTurns));
+      }
+      if (config.extraArgs) {
+        args.push(...config.extraArgs);
+      }
+      if (config.model) {
+        args.push("--model", config.model);
+      }
+      return args;
+    },
+    buildResumeArgs(nativeSessionId, config) {
+      const args = [
+        "-r",
+        nativeSessionId,
+        "-p",
+        config.prompt ?? "Continue working",
+        "--output-format",
+        "streaming-json",
+        "--always-approve"
+      ];
+      if (config.extraArgs) {
+        args.push(...config.extraArgs);
+      }
+      if (config.model) {
+        args.push("--model", config.model);
+      }
+      return args;
+    },
+    buildInteractiveArgs(config) {
+      const args = ["--always-approve"];
+      if (config.extraArgs) {
+        args.push(...config.extraArgs);
+      }
+      if (config.model) {
+        args.push("--model", config.model);
+      }
+      return args;
+    },
+    buildInteractiveResumeArgs(nativeSessionId, config) {
+      const args = ["-r", nativeSessionId, "--always-approve"];
+      if (config.extraArgs) {
+        args.push(...config.extraArgs);
+      }
+      if (config.model) {
+        args.push("--model", config.model);
+      }
+      return args;
+    },
+    resolveTranscriptPath(nativeSessionId, cwd) {
+      const scopedPath = buildTranscriptPath2(cwd, nativeSessionId);
+      if (existsSync13(scopedPath)) return scopedPath;
+      const root = getGrokSessionsRoot();
+      if (!existsSync13(root)) return scopedPath;
+      try {
+        for (const scope of readdirSync6(root, { withFileTypes: true })) {
+          if (!scope.isDirectory()) continue;
+          const candidate = join93(root, scope.name, nativeSessionId, GROK_TRANSCRIPT_FILE);
+          if (existsSync13(candidate)) return candidate;
+        }
+      } catch {
+      }
+      return scopedPath;
+    },
+    createWatcher(transcriptPath) {
+      return createJsonlTranscriptWatcher(transcriptPath, {
+        createState: () => createGrokMapperContext({ transcriptPath }),
+        map: (entry, state) => mapGrokEntry(entry, state)
+      });
+    },
+    parseTranscript(content, options3) {
+      return parseGrokTranscript(content, { transcriptPath: options3?.transcriptPath });
+    },
+    async isAvailable() {
+      return (await getExecutable("grok")).available;
+    }
+  };
+}
+var GROK_COMMAND;
+var GROK_TRANSCRIPT_FILE;
+var TRANSCRIPT_DISCOVERY_PADDING_MS3;
+var init_grok2 = __esm2({
+  "src/harness/grok.ts"() {
+    "use strict";
+    init_grok();
+    init_jsonl_watcher();
+    init_config();
+    init_executable();
+    GROK_COMMAND = "grok";
+    GROK_TRANSCRIPT_FILE = "chat_history.jsonl";
+    TRANSCRIPT_DISCOVERY_PADDING_MS3 = 5 * 6e4;
+  }
+});
 function diffEntries2(previous, next) {
   const limit = Math.min(previous.length, next.length);
   let index = 0;
@@ -165288,7 +166004,7 @@ var init_opencode_session_watcher = __esm2({
         return [...this.entries];
       }
       startStreamMode() {
-        if (existsSync13(this.transcriptPath)) {
+        if (existsSync14(this.transcriptPath)) {
           this.readStreamUpdates();
         }
         watchFile3(this.transcriptPath, { interval: this.options.pollIntervalMs, persistent: false }, () => {
@@ -165296,11 +166012,11 @@ var init_opencode_session_watcher = __esm2({
         });
       }
       refreshSessionSnapshot() {
-        if (!this.started || !existsSync13(this.transcriptPath)) {
+        if (!this.started || !existsSync14(this.transcriptPath)) {
           return;
         }
         try {
-          const content = readFileSync10(this.transcriptPath, "utf-8");
+          const content = readFileSync11(this.transcriptPath, "utf-8");
           const nextEntries = parseOpencodeTranscript(content, { transcriptPath: this.transcriptPath });
           const newEntries = diffEntries2(this.entries, nextEntries);
           if (newEntries.length === 0 && nextEntries.length === this.entries.length) {
@@ -165315,12 +166031,12 @@ var init_opencode_session_watcher = __esm2({
         }
       }
       readStreamUpdates() {
-        if (!this.started || !existsSync13(this.transcriptPath)) {
+        if (!this.started || !existsSync14(this.transcriptPath)) {
           return;
         }
         let fileSize = 0;
         try {
-          fileSize = statSync5(this.transcriptPath).size;
+          fileSize = statSync6(this.transcriptPath).size;
         } catch (error3) {
           this.reportError(error3, "Failed to stat OpenCode stream capture");
           return;
@@ -165333,7 +166049,7 @@ var init_opencode_session_watcher = __esm2({
           return;
         }
         try {
-          const raw = readFileSync10(this.transcriptPath);
+          const raw = readFileSync11(this.transcriptPath);
           const chunk = raw.subarray(this.byteOffset).toString("utf-8");
           this.byteOffset = raw.length;
           const text = `${this.buffer}${chunk}`;
@@ -165394,35 +166110,35 @@ function isTranscriptRecentEnough3(transcriptPath, startedAt) {
     return true;
   }
   try {
-    return statSync6(transcriptPath).mtimeMs >= startedAtMs - OPENCODE_NATIVE_DISCOVERY_PADDING_MS;
+    return statSync7(transcriptPath).mtimeMs >= startedAtMs - OPENCODE_NATIVE_DISCOVERY_PADDING_MS;
   } catch {
     return true;
   }
 }
 function getOpencodeStorageRoot() {
-  return join93(homedir62(), ".local", "share", "opencode", "storage");
+  return join103(homedir72(), ".local", "share", "opencode", "storage");
 }
 function getOpencodeSessionRoot() {
-  return join93(getOpencodeStorageRoot(), "session");
+  return join103(getOpencodeStorageRoot(), "session");
 }
 function getOpencodeProjectRoot() {
-  return join93(getOpencodeStorageRoot(), "project");
+  return join103(getOpencodeStorageRoot(), "project");
 }
 function getOpencodeStreamCaptureDir() {
-  return join93(getOpencodeStorageRoot(), "orbh");
+  return join103(getOpencodeStorageRoot(), "orbh");
 }
 function buildPendingOpencodeStreamCapturePath(orbhSessionId) {
-  return join93(getOpencodeStreamCaptureDir(), `${orbhSessionId}.jsonl`);
+  return join103(getOpencodeStreamCaptureDir(), `${orbhSessionId}.jsonl`);
 }
 function buildOpencodeStreamCapturePath(nativeSessionId) {
-  return join93(getOpencodeStreamCaptureDir(), `${nativeSessionId}.jsonl`);
+  return join103(getOpencodeStreamCaptureDir(), `${nativeSessionId}.jsonl`);
 }
 function readNativeSessionIdFromStreamCapture(streamPath) {
-  if (!existsSync14(streamPath)) {
+  if (!existsSync15(streamPath)) {
     return null;
   }
   try {
-    const lines = readFileSync11(streamPath, "utf-8").split(/\r?\n/);
+    const lines = readFileSync12(streamPath, "utf-8").split(/\r?\n/);
     for (const line of lines) {
       const trimmed = line.trim();
       if (trimmed.length === 0) {
@@ -165463,17 +166179,17 @@ function mergeOpencodeConfigContent(existing, patch) {
 }
 function listProjectIdsForCwd(cwd) {
   const projectsRoot = getOpencodeProjectRoot();
-  if (!existsSync14(projectsRoot)) {
+  if (!existsSync15(projectsRoot)) {
     return [];
   }
   const normalizedCwd = normalizePath(cwd);
   const projectIds = [];
-  for (const entry of readdirSync6(projectsRoot)) {
+  for (const entry of readdirSync7(projectsRoot)) {
     if (!entry.endsWith(".json")) {
       continue;
     }
     try {
-      const parsed = JSON.parse(readFileSync11(join93(projectsRoot, entry), "utf-8"));
+      const parsed = JSON.parse(readFileSync12(join103(projectsRoot, entry), "utf-8"));
       const worktree = typeof parsed.worktree === "string" ? parsed.worktree : typeof parsed.directory === "string" ? parsed.directory : null;
       if (!worktree || typeof parsed.id !== "string") {
         continue;
@@ -165489,26 +166205,26 @@ function listProjectIdsForCwd(cwd) {
 }
 function readOpencodeSessionId(transcriptPath) {
   try {
-    const parsed = JSON.parse(readFileSync11(transcriptPath, "utf-8"));
-    return typeof parsed.id === "string" ? parsed.id : basename33(transcriptPath, ".json");
+    const parsed = JSON.parse(readFileSync12(transcriptPath, "utf-8"));
+    return typeof parsed.id === "string" ? parsed.id : basename43(transcriptPath, ".json");
   } catch {
-    return basename33(transcriptPath, ".json");
+    return basename43(transcriptPath, ".json");
   }
 }
 function listOpencodeSessionPaths(cwd) {
   const sessionPaths = /* @__PURE__ */ new Map();
   for (const projectId of listProjectIdsForCwd(cwd)) {
-    const sessionDir = join93(getOpencodeSessionRoot(), projectId);
-    if (!existsSync14(sessionDir)) {
+    const sessionDir = join103(getOpencodeSessionRoot(), projectId);
+    if (!existsSync15(sessionDir)) {
       continue;
     }
-    for (const entry of readdirSync6(sessionDir)) {
+    for (const entry of readdirSync7(sessionDir)) {
       if (!entry.startsWith("ses_") || !entry.endsWith(".json")) {
         continue;
       }
-      const transcriptPath = join93(sessionDir, entry);
+      const transcriptPath = join103(sessionDir, entry);
       try {
-        sessionPaths.set(transcriptPath, statSync6(transcriptPath).mtimeMs);
+        sessionPaths.set(transcriptPath, statSync7(transcriptPath).mtimeMs);
       } catch {
         continue;
       }
@@ -165518,17 +166234,17 @@ function listOpencodeSessionPaths(cwd) {
 }
 function findOpencodeSessionPath(nativeSessionId, cwd) {
   for (const transcriptPath of listOpencodeSessionPaths(cwd)) {
-    if (basename33(transcriptPath, ".json") === nativeSessionId) {
+    if (basename43(transcriptPath, ".json") === nativeSessionId) {
       return transcriptPath;
     }
   }
   const sessionRoot = getOpencodeSessionRoot();
-  if (!existsSync14(sessionRoot)) {
+  if (!existsSync15(sessionRoot)) {
     return null;
   }
-  for (const projectId of readdirSync6(sessionRoot)) {
-    const candidate = join93(sessionRoot, projectId, `${nativeSessionId}.json`);
-    if (existsSync14(candidate)) {
+  for (const projectId of readdirSync7(sessionRoot)) {
+    const candidate = join103(sessionRoot, projectId, `${nativeSessionId}.json`);
+    if (existsSync15(candidate)) {
       return candidate;
     }
   }
@@ -165539,28 +166255,28 @@ function sessionContainsOrbhSessionId(transcriptPath, orbhSessionId) {
   if (!nativeSessionId) {
     return false;
   }
-  const storageRoot = join93(getOpencodeStorageRoot());
-  const messageDir = join93(storageRoot, "message", nativeSessionId);
-  if (!existsSync14(messageDir)) {
+  const storageRoot = join103(getOpencodeStorageRoot());
+  const messageDir = join103(storageRoot, "message", nativeSessionId);
+  if (!existsSync15(messageDir)) {
     return false;
   }
-  for (const entry of readdirSync6(messageDir)) {
-    const messagePath = join93(messageDir, entry);
+  for (const entry of readdirSync7(messageDir)) {
+    const messagePath = join103(messageDir, entry);
     try {
-      if (readFileSync11(messagePath, "utf-8").includes(orbhSessionId)) {
+      if (readFileSync12(messagePath, "utf-8").includes(orbhSessionId)) {
         return true;
       }
     } catch {
       continue;
     }
-    const messageId = basename33(entry, ".json");
-    const partDir = join93(storageRoot, "part", messageId);
-    if (!existsSync14(partDir)) {
+    const messageId = basename43(entry, ".json");
+    const partDir = join103(storageRoot, "part", messageId);
+    if (!existsSync15(partDir)) {
       continue;
     }
-    for (const partEntry of readdirSync6(partDir)) {
+    for (const partEntry of readdirSync7(partDir)) {
       try {
-        if (readFileSync11(join93(partDir, partEntry), "utf-8").includes(orbhSessionId)) {
+        if (readFileSync12(join103(partDir, partEntry), "utf-8").includes(orbhSessionId)) {
           return true;
         }
       } catch {
@@ -165706,7 +166422,7 @@ function createOpencodeHarness() {
     },
     resolveTranscriptPath(nativeSessionId, cwd) {
       const streamCapturePath = buildOpencodeStreamCapturePath(nativeSessionId);
-      if (existsSync14(streamCapturePath)) {
+      if (existsSync15(streamCapturePath)) {
         return streamCapturePath;
       }
       return findOpencodeSessionPath(nativeSessionId, cwd);
@@ -165769,6 +166485,7 @@ var init_registry = __esm2({
     init_codex2();
     init_droid2();
     init_gemini2();
+    init_grok2();
     init_opencode2();
     registry = /* @__PURE__ */ new Map();
     defaultHarnessRegistry = registry;
@@ -165776,6 +166493,7 @@ var init_registry = __esm2({
     registerHarness(createCodexHarness());
     registerHarness(createDroidHarness());
     registerHarness(createGeminiHarness());
+    registerHarness(createGrokHarness());
     registerHarness(createOpencodeHarness());
   }
 });
@@ -166193,7 +166911,7 @@ function healSessionWithOptions(session, _options) {
   return true;
 }
 var getPendingQuestion = getPendingRequest;
-function isRecord7(value) {
+function isRecord8(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function normalizeMessages(value) {
@@ -166201,7 +166919,7 @@ function normalizeMessages(value) {
     return [];
   }
   return value.flatMap((entry) => {
-    if (!isRecord7(entry)) {
+    if (!isRecord8(entry)) {
       return [];
     }
     const { id, from, text, timestamp, delivered } = entry;
@@ -166215,18 +166933,18 @@ function normalizeSession(session) {
   return {
     ...session,
     model: typeof session.model === "string" && session.model.length > 0 ? session.model : null,
-    metadata: isRecord7(session.metadata) ? session.metadata : {},
-    hooks: isRecord7(session.hooks) ? session.hooks : {},
+    metadata: isRecord8(session.metadata) ? session.metadata : {},
+    hooks: isRecord8(session.hooks) ? session.hooks : {},
     messages: normalizeMessages(session.messages)
   };
 }
 function ensureSessionsDir(sessionsDir) {
-  if (!existsSync15(sessionsDir)) {
+  if (!existsSync16(sessionsDir)) {
     mkdirSync3(sessionsDir, { recursive: true });
   }
 }
 function getSessionPath(sessionsDir, sessionId) {
-  return join37(sessionsDir, `${sessionId}.json`);
+  return join38(sessionsDir, `${sessionId}.json`);
 }
 function createSession(sessionsDir, runtime2, prompt6, options3) {
   ensureSessionsDir(sessionsDir);
@@ -166253,7 +166971,7 @@ function createSession(sessionsDir, runtime2, prompt6, options3) {
 }
 function readSession(sessionsDir, sessionId) {
   const sessionPath = getSessionPath(sessionsDir, sessionId);
-  if (!existsSync15(sessionPath)) {
+  if (!existsSync16(sessionPath)) {
     return null;
   }
   try {
@@ -166292,7 +167010,7 @@ function updateSession(sessionsDir, sessionId, update, options3) {
   return nextSession;
 }
 function listSessions(sessionsDir) {
-  if (!existsSync15(sessionsDir)) {
+  if (!existsSync16(sessionsDir)) {
     return [];
   }
   return readdirSync(sessionsDir).filter((entry) => entry.endsWith(".json")).map((entry) => readSession(sessionsDir, entry.slice(0, -5))).filter((session) => session !== null).sort((a, b) => b.started.localeCompare(a.started));
@@ -166487,7 +167205,7 @@ var DEFAULTS = {
   includeUsage: true,
   includeSubagents: true
 };
-function truncate3(text, max) {
+function truncate4(text, max) {
   if (text.length <= max) return text;
   return text.slice(0, max) + "\n... (truncated)";
 }
@@ -166500,7 +167218,7 @@ function formatToolUse(tool, opts, depth) {
   lines.push("");
   if (inputStr) {
     lines.push("````json");
-    lines.push(truncate3(inputStr, opts.maxToolInputLength));
+    lines.push(truncate4(inputStr, opts.maxToolInputLength));
     lines.push("````");
     lines.push("");
   }
@@ -166509,7 +167227,7 @@ function formatToolUse(tool, opts, depth) {
     lines.push(resultLabel);
     lines.push("");
     lines.push("````");
-    lines.push(truncate3(tool.output, opts.maxToolOutputLength));
+    lines.push(truncate4(tool.output, opts.maxToolOutputLength));
     lines.push("````");
     lines.push("");
   }
@@ -166927,6 +167645,7 @@ init_config();
 init_executable();
 init_droid2();
 init_gemini2();
+init_grok2();
 init_opencode2();
 init_executable();
 init_gemini2();
@@ -166952,7 +167671,7 @@ function buildHarnessSpawnEnv(cwd, sessionId, sessionsDir, baseEnv = process.env
   delete env3.CODEX_THREAD_ID;
   delete env3.CODEX_CI;
   delete env3.CODEX_SESSION_ID;
-  const localBin = join103(homedir72(), ".local", "bin");
+  const localBin = join113(homedir82(), ".local", "bin");
   if (env3.PATH && !env3.PATH.startsWith(localBin)) {
     env3.PATH = `${localBin}:${env3.PATH}`;
   }
@@ -166984,29 +167703,29 @@ function sendNotification(session, exitCode) {
   }
 }
 function listRecentCodexRollouts() {
-  const sessionsRoot = join103(homedir72(), ".codex", "sessions");
-  if (!existsSync152(sessionsRoot)) {
+  const sessionsRoot = join113(homedir82(), ".codex", "sessions");
+  if (!existsSync162(sessionsRoot)) {
     return [];
   }
   const paths = [];
-  for (const year of readdirSync7(sessionsRoot, { withFileTypes: true })) {
+  for (const year of readdirSync8(sessionsRoot, { withFileTypes: true })) {
     if (!year.isDirectory()) {
       continue;
     }
-    const yearPath = join103(sessionsRoot, year.name);
-    for (const month of readdirSync7(yearPath, { withFileTypes: true })) {
+    const yearPath = join113(sessionsRoot, year.name);
+    for (const month of readdirSync8(yearPath, { withFileTypes: true })) {
       if (!month.isDirectory()) {
         continue;
       }
-      const monthPath = join103(yearPath, month.name);
-      for (const day of readdirSync7(monthPath, { withFileTypes: true })) {
+      const monthPath = join113(yearPath, month.name);
+      for (const day of readdirSync8(monthPath, { withFileTypes: true })) {
         if (!day.isDirectory()) {
           continue;
         }
-        const dayPath = join103(monthPath, day.name);
-        for (const fileName of readdirSync7(dayPath)) {
+        const dayPath = join113(monthPath, day.name);
+        for (const fileName of readdirSync8(dayPath)) {
           if (fileName.startsWith("rollout-") && fileName.endsWith(".jsonl")) {
-            paths.push(join103(dayPath, fileName));
+            paths.push(join113(dayPath, fileName));
           }
         }
       }
@@ -167018,7 +167737,7 @@ function listCodexNativeSessionCandidates(cwd) {
   const candidates = [];
   for (const rolloutPath of listRecentCodexRollouts()) {
     try {
-      const [firstLine] = readFileSync12(rolloutPath, "utf-8").split("\n");
+      const [firstLine] = readFileSync13(rolloutPath, "utf-8").split("\n");
       if (!firstLine) {
         continue;
       }
@@ -167087,7 +167806,7 @@ async function spawnHarnessProcess(options3) {
     return buildPendingOpencodeStreamCapturePath(options3.sessionId);
   })() : null;
   const opencodeStreamCapture = opencodeStreamCapturePath ? createWriteStream(opencodeStreamCapturePath, { flags: "w" }) : null;
-  const child = spawn23(spawnCmd, [...executable.resolvedCommand.prependArgs, ...harness.buildSpawnArgs(options3.config)], {
+  const child = spawn32(spawnCmd, [...executable.resolvedCommand.prependArgs, ...harness.buildSpawnArgs(options3.config)], {
     cwd: options3.cwd,
     detached: process.platform !== "win32",
     windowsHide: true,
@@ -167327,13 +168046,13 @@ function parseProfileTarget(target) {
   return { runtime: runtime2, name, explicitProfile: true };
 }
 function getProfilesPath() {
-  return join113(homedir82(), ".nuucognition", "orbh", "profiles.json");
+  return join123(homedir9(), ".nuucognition", "orbh", "profiles.json");
 }
 function loadProfiles(filePath = getProfilesPath()) {
-  if (!existsSync16(filePath)) {
+  if (!existsSync17(filePath)) {
     return {};
   }
-  const raw = readFileSync13(filePath, "utf-8").trim();
+  const raw = readFileSync14(filePath, "utf-8").trim();
   if (!raw) {
     return {};
   }
@@ -167378,11 +168097,200 @@ function resolveTarget(target, profiles) {
     } : null
   };
 }
+function stripInteractivePrefix(title) {
+  return title.replace(/^\(Interactive\)\s*/i, "").trim();
+}
+function extractIcon(inner) {
+  return inner.trimStart().match(/^[^\x00-\x7F]+/)?.[0].trim() ?? "";
+}
+function runtimeLabel(runtime2) {
+  if (!runtime2) return "";
+  const overrides = { opencode: "OpenCode" };
+  const key = runtime2.toLowerCase();
+  if (overrides[key]) return overrides[key];
+  return key.charAt(0).toUpperCase() + key.slice(1);
+}
+function composeTitle(opts) {
+  const icon = extractIcon(opts.inner);
+  const shortId2 = opts.sessionId.slice(0, 8);
+  const label = runtimeLabel(opts.runtime);
+  const withPrefix2 = (composed) => {
+    const trimmed = composed.trim();
+    if (!label) return trimmed;
+    if (!trimmed) return `${label}:`;
+    return `${label}: ${trimmed}`;
+  };
+  if (opts.titleTransform) {
+    return withPrefix2(
+      opts.titleTransform({
+        inner: opts.inner,
+        icon,
+        title: opts.title,
+        sessionId: opts.sessionId,
+        shortId: shortId2,
+        runtime: opts.runtime,
+        cwd: opts.cwd
+      })
+    );
+  }
+  if (opts.titleFormat) {
+    return withPrefix2(
+      opts.titleFormat.replaceAll("{inner}", opts.inner).replaceAll("{icon}", icon).replaceAll("{title}", opts.title).replaceAll("{sessionId}", opts.sessionId).replaceAll("{shortId}", shortId2).replaceAll("{runtime}", opts.runtime).replaceAll("{cwd}", opts.cwd)
+    );
+  }
+  let body;
+  if (opts.title.length === 0) body = icon.length > 0 ? icon : opts.inner;
+  else if (icon.length === 0) body = opts.title;
+  else body = `${opts.title} ${icon}`;
+  return withPrefix2(body);
+}
+async function spawnWithTitleRewrite(opts) {
+  let pty;
+  try {
+    pty = await import("node-pty");
+  } catch (err) {
+    throw new Error(
+      `Title rewriting requires the 'node-pty' optional dependency. Install it or omit --title-format. Original error: ${String(err)}`
+    );
+  }
+  const cols = process.stdout.columns ?? 120;
+  const rows = process.stdout.rows ?? 30;
+  const term = pty.spawn(opts.cmd, opts.args, {
+    name: process.env.TERM ?? "xterm-256color",
+    cols,
+    rows,
+    cwd: opts.cwd,
+    env: opts.env
+  });
+  const emitter = new EventEmitter2();
+  emitter.pid = term.pid;
+  emitter.stderr = null;
+  emitter.kill = (signal) => {
+    try {
+      term.kill(typeof signal === "string" ? signal : void 0);
+    } catch {
+    }
+    return true;
+  };
+  const stdinWasRaw = process.stdin.isTTY ? process.stdin.isRaw : false;
+  if (process.stdin.isTTY && !stdinWasRaw) {
+    process.stdin.setRawMode(true);
+  }
+  process.stdin.resume();
+  const onStdin = (data) => term.write(data.toString("utf8"));
+  process.stdin.on("data", onStdin);
+  const onResize = () => {
+    try {
+      term.resize(process.stdout.columns ?? cols, process.stdout.rows ?? rows);
+    } catch {
+    }
+  };
+  process.stdout.on("resize", onResize);
+  const OSC_TITLE = /\x1b\]([012]);([^\x07\x1b]*)(\x07|\x1b\\)/g;
+  const currentTitle = () => {
+    const raw = opts.getSessionTitle?.() ?? "";
+    return stripInteractivePrefix(raw);
+  };
+  const rewrite = (inner) => composeTitle({
+    inner,
+    title: currentTitle(),
+    sessionId: opts.sessionId,
+    runtime: opts.runtime,
+    cwd: opts.cwd,
+    titleFormat: opts.titleFormat,
+    titleTransform: opts.titleTransform
+  });
+  let lastInner = "";
+  let lastTitle = currentTitle();
+  let lastEmitted = null;
+  const emit = (composed) => {
+    if (composed === lastEmitted) return;
+    lastEmitted = composed;
+    process.stdout.write(`\x1B]0;${composed}\x07`);
+  };
+  const pollTick = () => {
+    const title = currentTitle();
+    if (title === lastTitle) return;
+    lastTitle = title;
+    emit(rewrite(lastInner));
+  };
+  term.onData((chunk) => {
+    const out = chunk.replace(OSC_TITLE, (_match, selector, inner, terminator) => {
+      lastInner = inner;
+      lastTitle = currentTitle();
+      const composed = rewrite(inner);
+      lastEmitted = composed;
+      return `\x1B]${selector};${composed}${terminator}`;
+    });
+    process.stdout.write(out);
+  });
+  emit(rewrite(""));
+  const pollMs = opts.titlePollMs ?? 1e3;
+  const pollTimer = pollMs > 0 && opts.getSessionTitle ? setInterval(pollTick, pollMs) : null;
+  term.onExit(({ exitCode, signal }) => {
+    if (pollTimer) clearInterval(pollTimer);
+    process.stdin.off("data", onStdin);
+    process.stdout.off("resize", onResize);
+    if (process.stdin.isTTY) {
+      try {
+        process.stdin.setRawMode(stdinWasRaw);
+      } catch {
+      }
+    }
+    process.stdin.pause();
+    if (opts.exitTitle && process.stdout.isTTY) {
+      process.stdout.write(`\x1B]0;${opts.exitTitle}\x07`);
+    }
+    emitter.emit("exit", exitCode, signal ? String(signal) : null);
+  });
+  return emitter;
+}
+function resolveTitleFormat(explicit) {
+  if (typeof explicit === "string" && explicit.length > 0) return explicit;
+  const env3 = process.env.ORBH_TITLE_FORMAT;
+  if (typeof env3 === "string" && env3.length > 0) return env3;
+  return void 0;
+}
+function canRewriteTitle() {
+  return Boolean(process.stdout.isTTY && process.stdin.isTTY);
+}
+async function spawnInteractiveChild(opts) {
+  if (canRewriteTitle()) {
+    try {
+      const format = resolveTitleFormat(opts.titleFormat);
+      const getSessionTitle = () => {
+        const session = readSession(opts.sessionsDir, opts.sessionId);
+        return session?.title ?? void 0;
+      };
+      return await spawnWithTitleRewrite({
+        cmd: opts.cmd,
+        args: opts.args,
+        cwd: opts.cwd,
+        env: opts.env,
+        sessionId: opts.sessionId,
+        runtime: opts.runtime,
+        titleFormat: format,
+        titleTransform: opts.titleTransform,
+        exitTitle: opts.titleOnExit ?? opts.runtime,
+        getSessionTitle
+      });
+    } catch (err) {
+      process.stderr.write(`orbh: title rewriting disabled (${err.message})
+`);
+    }
+  }
+  return spawn42(opts.cmd, opts.args, {
+    cwd: opts.cwd,
+    stdio: "inherit",
+    windowsHide: true,
+    env: opts.env
+  });
+}
 var DEFAULT_RUNTIME_PREFERENCE = ["codex", "claude", "gemini", "droid"];
 var READY_TIMEOUT_MS = 1e4;
 var COMPLETION_TIMEOUT_MS = 30 * 60 * 1e3;
 var POLL_INTERVAL_MS = 250;
-function sleep(ms) {
+function sleep2(ms) {
   return new Promise((resolve19) => setTimeout(resolve19, ms));
 }
 async function waitForSession(sessionsDir, sessionId, predicate, timeoutMs) {
@@ -167392,7 +168300,7 @@ async function waitForSession(sessionsDir, sessionId, predicate, timeoutMs) {
     if (session && predicate(session)) {
       return session;
     }
-    await sleep(POLL_INTERVAL_MS);
+    await sleep2(POLL_INTERVAL_MS);
   }
   throw new Error(`Timed out while waiting for Orbh session '${sessionId}'.`);
 }
@@ -167645,7 +168553,7 @@ async function spawnDetachedResume(session, harness, options3) {
     throw new Error(`Orbh runtime '${harness.name}' is not installed or not available.`);
   }
   const spawnCmd = executable.resolvedCommand.cmd;
-  const child = spawn32(spawnCmd, [...executable.resolvedCommand.prependArgs, ...args], {
+  const child = spawn42(spawnCmd, [...executable.resolvedCommand.prependArgs, ...args], {
     cwd: options3.cwd,
     detached: process.platform !== "win32",
     windowsHide: true,
@@ -167690,7 +168598,8 @@ async function spawnDetachedResume(session, harness, options3) {
 }
 async function waitForInteractiveResult(child, options3, session, runtime2) {
   let stderr = "";
-  child.stderr?.on("data", (chunk) => {
+  const stderrStream = child.stderr;
+  stderrStream?.on("data", (chunk) => {
     stderr += chunk.toString();
   });
   return new Promise((resolve19, reject) => {
@@ -167847,11 +168756,19 @@ async function launchInteractive(options3) {
     writeSession(options3.sessionsDir, session2);
     const executable2 = await getExecutable(harness2.name);
     const spawnCmd2 = executable2.resolvedCommand.cmd;
-    const child2 = spawn32(spawnCmd2, [...executable2.resolvedCommand.prependArgs, ...args2], {
+    const spawnArgs2 = [...executable2.resolvedCommand.prependArgs, ...args2];
+    const spawnEnv2 = buildHarnessSpawnEnv(options3.cwd, session2.id, options3.sessionsDir);
+    const child2 = await spawnInteractiveChild({
+      cmd: spawnCmd2,
+      args: spawnArgs2,
       cwd: options3.cwd,
-      stdio: "inherit",
-      windowsHide: true,
-      env: buildHarnessSpawnEnv(options3.cwd, session2.id, options3.sessionsDir)
+      env: spawnEnv2,
+      sessionId: session2.id,
+      sessionsDir: options3.sessionsDir,
+      runtime: harness2.name,
+      titleFormat: options3.titleFormat,
+      titleTransform: options3.titleTransform,
+      titleOnExit: options3.titleOnExit
     });
     if (child2.pid) {
       updateCurrentRun(session2, { pid: child2.pid, status: "running" });
@@ -167926,6 +168843,17 @@ async function launchInteractive(options3) {
       model: options3.model,
       extraArgs: appliedConfig.extraArgs
     });
+  } else if (harness.name === "grok") {
+    nativeSessionId = await bootstrapGrokSession(options3.cwd, config.prompt, {
+      env: appliedConfig.env,
+      model: resolvedModel,
+      extraArgs: appliedConfig.extraArgs
+    });
+    args = interactiveResumeArgs(nativeSessionId, {
+      cwd: options3.cwd,
+      model: options3.model,
+      extraArgs: appliedConfig.extraArgs
+    });
   } else {
     if (!interactiveArgs) {
       throw new Error(`Runtime '${harness.name}' does not support interactive launch.`);
@@ -167945,11 +168873,19 @@ async function launchInteractive(options3) {
   writeSession(options3.sessionsDir, session);
   const executable = await getExecutable(harness.name);
   const spawnCmd = executable.resolvedCommand.cmd;
-  const child = spawn32(spawnCmd, [...executable.resolvedCommand.prependArgs, ...args], {
+  const spawnArgs = [...executable.resolvedCommand.prependArgs, ...args];
+  const spawnEnv = buildHarnessSpawnEnv(options3.cwd, session.id, options3.sessionsDir, process.env, appliedConfig.env);
+  const child = await spawnInteractiveChild({
+    cmd: spawnCmd,
+    args: spawnArgs,
     cwd: options3.cwd,
-    stdio: "inherit",
-    windowsHide: true,
-    env: buildHarnessSpawnEnv(options3.cwd, session.id, options3.sessionsDir, process.env, appliedConfig.env)
+    env: spawnEnv,
+    sessionId: session.id,
+    sessionsDir: options3.sessionsDir,
+    runtime: harness.name,
+    titleFormat: options3.titleFormat,
+    titleTransform: options3.titleTransform,
+    titleOnExit: options3.titleOnExit
   });
   if (child.pid) {
     updateCurrentRun(session, { pid: child.pid, status: "running" });
@@ -167986,9 +168922,9 @@ init_registry();
 init_dist();
 import { access as access8, readFile as readFile15 } from "fs/promises";
 import path23 from "path";
-import { homedir as homedir9 } from "os";
+import { homedir as homedir10 } from "os";
 import { randomUUID as randomUUID8 } from "crypto";
-import { spawn as spawn7 } from "child_process";
+import { spawn as spawn8 } from "child_process";
 import { readFile as readFile26 } from "fs/promises";
 import Fastify from "fastify";
 import { readFile as readFile36, writeFile as writeFile13, mkdir as mkdir17, rm as rm13 } from "fs/promises";
@@ -167997,15 +168933,15 @@ var DEFAULT_HOST = "127.0.0.1";
 var DEFAULT_PORT = 13041;
 var DEFAULT_SESSIONS_DIR = ".orbh/sessions";
 var DEFAULT_CONFIG_FILENAME = "orbh.toml";
-function isRecord8(value) {
+function isRecord9(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function expandHome(value) {
   if (value === "~") {
-    return homedir9();
+    return homedir10();
   }
   if (value.startsWith("~/")) {
-    return path23.join(homedir9(), value.slice(2));
+    return path23.join(homedir10(), value.slice(2));
   }
   return value;
 }
@@ -168026,7 +168962,7 @@ function normalizeSessionsDir(value) {
   return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
 }
 function normalizeRuntimeOverrides(value) {
-  if (!isRecord8(value)) {
+  if (!isRecord9(value)) {
     return {};
   }
   const overrides = {};
@@ -168046,7 +168982,7 @@ async function maybeReadConfig(configPath) {
   }
   const content = await readFile15(configPath, "utf-8");
   const parsed = parse2(content);
-  if (!isRecord8(parsed)) {
+  if (!isRecord9(parsed)) {
     throw new Error(`Invalid ${DEFAULT_CONFIG_FILENAME}: expected a TOML object`);
   }
   return parsed;
@@ -169022,7 +169958,7 @@ var OrbhService = class {
       extraArgs: DEFAULT_EXTRA_ARGS_BY_RUNTIME[session.runtime] ?? []
     };
     const spawnCmd = executable.resolvedPath ?? executable.resolvedCommand.cmd;
-    const child = spawn7(
+    const child = spawn8(
       spawnCmd,
       [...executable.resolvedCommand.prependArgs, ...args],
       {
@@ -169799,7 +170735,7 @@ async function getOrbhServerStatus(options3 = {}) {
 }
 
 // ../orbh-cli/src/await.ts
-function isRecord9(value) {
+function isRecord10(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function normalizeKey(value) {
@@ -169827,7 +170763,7 @@ function collectScalarMatches(value, path30, matches) {
     });
     return;
   }
-  if (!isRecord9(value)) {
+  if (!isRecord10(value)) {
     return;
   }
   for (const [key, entry] of Object.entries(value)) {
@@ -169978,7 +170914,7 @@ async function waitForOrbhEvent(options3) {
 // ../../node_modules/.pnpm/strip-ansi@7.2.0/node_modules/strip-ansi/index.js
 init_ansi_regex();
 var regex2 = ansiRegex2();
-function stripAnsi3(string) {
+function stripAnsi4(string) {
   if (typeof string !== "string") {
     throw new TypeError(`Expected a \`string\`, got \`${typeof string}\``);
   }
@@ -170125,7 +171061,7 @@ function stringWidth(input, options3 = {}) {
   } = options3;
   let string = input;
   if (!countAnsiEscapeCodes && (string.includes("\x1B") || string.includes("\x9B"))) {
-    string = stripAnsi3(string);
+    string = stripAnsi4(string);
   }
   if (string.length === 0) {
     return 0;
@@ -170525,7 +171461,7 @@ var wrapWord = (rows, word, columns) => {
   const characters = getGraphemes(word);
   let isInsideEscape = false;
   let isInsideLinkEscape = false;
-  let visible = stringWidth(stripAnsi3(rows.at(-1)));
+  let visible = stringWidth(stripAnsi4(rows.at(-1)));
   for (const [index, character] of characters.entries()) {
     const characterLength = stringWidth(character);
     if (visible + characterLength <= columns) {
@@ -170684,7 +171620,7 @@ function wrapAnsi(string, columns, options3) {
 // ../orbh-cli/src/terminal-format.ts
 var VALID_STATUSES = ["queued", "in-progress", "blocked", "deferred", "finished", "failed", "cancelled"];
 var ANSI_PATTERN = /\u001B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g;
-function stripAnsi4(text) {
+function stripAnsi5(text) {
   return text.replace(ANSI_PATTERN, "");
 }
 function padVisible(text, width) {
@@ -170695,14 +171631,14 @@ function wrapToWidth(text, width) {
   const wrapped = wrapAnsi(text, Math.max(1, width), { hard: true, wordWrap: true, trim: false });
   return wrapped.split("\n");
 }
-function truncate4(text, maxLen) {
+function truncate5(text, maxLen) {
   if (maxLen === Number.POSITIVE_INFINITY || text.length <= maxLen) {
     return text;
   }
   return `${text.slice(0, maxLen)}...`;
 }
 function summarizeLines(text, maxLen) {
-  return truncate4(text.replace(/\s+/g, " ").trim(), maxLen);
+  return truncate5(text.replace(/\s+/g, " ").trim(), maxLen);
 }
 function stringifyValue4(value) {
   if (typeof value === "string") {
@@ -170719,7 +171655,7 @@ function formatToolInputSummary(tool, input, maxLen) {
     return input.file_path;
   }
   if (tool === "Bash" && typeof input.command === "string") {
-    return truncate4(input.command, maxLen);
+    return truncate5(input.command, maxLen);
   }
   if ((tool === "Glob" || tool === "Grep") && typeof input.pattern === "string") {
     return input.pattern;
@@ -170729,7 +171665,7 @@ function formatToolInputSummary(tool, input, maxLen) {
     const agentType = typeof input.subagent_type === "string" ? input.subagent_type : "";
     return agentType ? `[${agentType}] ${description}` : description;
   }
-  return truncate4(JSON.stringify(input), maxLen);
+  return truncate5(JSON.stringify(input), maxLen);
 }
 function extractAgentResultText(output) {
   const textParts = [];
@@ -170766,7 +171702,7 @@ function boxDivider(title, color, width) {
   let displayTitle = title;
   const vis = stringWidth(title);
   if (vis > maxTitle && maxTitle > 4) {
-    const plain = stripAnsi4(title);
+    const plain = stripAnsi5(title);
     displayTitle = export_pc.dim(plain.slice(0, maxTitle - 1) + "\u2026");
   }
   const displayVis = stringWidth(displayTitle);
@@ -171140,7 +172076,7 @@ var TranscriptWatchFormatter = class _TranscriptWatchFormatter {
     if (needsDivider) result.push(this.divider(""));
     result.push(this.wrap(export_pc.magenta(export_pc.bold("Compaction"))));
     if (entry.summary) {
-      result.push(...this.wrapContent(export_pc.dim(truncate4(entry.summary, this.maxSummaryLength))));
+      result.push(...this.wrapContent(export_pc.dim(truncate5(entry.summary, this.maxSummaryLength))));
     }
     return result;
   }
@@ -171246,7 +172182,7 @@ function readTranscriptEntries(session, transcriptCwd) {
     return null;
   }
   try {
-    const content = readFileSync14(transcriptPath, "utf-8");
+    const content = readFileSync15(transcriptPath, "utf-8");
     return harness.parseTranscript(content, { transcriptPath });
   } catch {
     return null;
@@ -171267,7 +172203,7 @@ async function defaultResumeDeferredSession(resumeContext) {
 }
 var REQUEST_SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
 var REQUEST_LAUNCH_OPTION_KEYS = ["runtime", "stream", "continues", "maxTurns", "budget", "model", "title", "description", "timeout"];
-function sleep2(ms) {
+function sleep3(ms) {
   return new Promise((resolve19) => setTimeout(resolve19, ms));
 }
 function getStringOption(options3, key) {
@@ -171482,7 +172418,7 @@ async function waitForSessionWithSpinner(sessionsDir, sessionId, timeoutMs) {
       process.stdout.write("\r\x1B[2K");
       return { session, timedOut: true };
     }
-    await sleep2(120);
+    await sleep3(120);
   }
 }
 async function waitForSessionQuiet(sessionsDir, sessionId, timeoutMs) {
@@ -171498,7 +172434,7 @@ async function waitForSessionQuiet(sessionsDir, sessionId, timeoutMs) {
     if (deadline !== null && Date.now() > deadline) {
       return { session, timedOut: true };
     }
-    await sleep2(500);
+    await sleep3(500);
   }
 }
 async function streamSessionTranscript(session, context, options3) {
@@ -171523,7 +172459,7 @@ async function streamSessionTranscript(session, context, options3) {
         process.stdout.write("\r\x1B[2K");
         return { session: readFreshSession(), timedOut: true };
       }
-      await sleep2(500);
+      await sleep3(500);
       current = readFreshSession();
       run2 = getCurrentRun(current);
       nativeId = run2?.nativeSessionId ?? current.id;
@@ -171541,14 +172477,14 @@ async function streamSessionTranscript(session, context, options3) {
   console.log(`${export_pc.bold("Watching")} ${export_pc.cyan(shortId(current.id))} ${export_pc.dim("\xB7")} ${current.runtime}${title} ${export_pc.dim("\xB7")} ${statusIcon(current.status)} ${current.status}`);
   console.log(export_pc.dim(transcriptPath));
   console.log("");
-  if (!existsSync17(transcriptPath)) {
+  if (!existsSync18(transcriptPath)) {
     process.stdout.write(export_pc.dim("Waiting for transcript..."));
-    while (!existsSync17(transcriptPath)) {
+    while (!existsSync18(transcriptPath)) {
       if (deadline !== null && Date.now() > deadline) {
         process.stdout.write("\r\x1B[2K");
         return { session: readFreshSession(), timedOut: true };
       }
-      await sleep2(500);
+      await sleep3(500);
     }
     process.stdout.write("\r\x1B[2K");
   }
@@ -171596,7 +172532,7 @@ async function streamSessionTranscript(session, context, options3) {
     while (true) {
       const fresh = readFreshSession();
       if (isTerminalStatus(fresh.status)) {
-        await sleep2(1e3);
+        await sleep3(1e3);
         if (entryCount > 0) {
           process.stdout.write("\r\x1B[2K");
         }
@@ -171626,7 +172562,7 @@ async function streamSessionTranscript(session, context, options3) {
         }, true));
         return { session: fresh, timedOut: true };
       }
-      await sleep2(250);
+      await sleep3(250);
     }
   } finally {
     watcher.stop();
@@ -172145,11 +173081,11 @@ ${export_pc.bold("Orbh Session Stats")} ${export_pc.dim("\xB7")} ${export_pc.cya
     console.log(`${export_pc.bold("Watching")} ${export_pc.cyan(shortId(session.id))} ${export_pc.dim("\xB7")} ${session.runtime}${title} ${export_pc.dim("\xB7")} ${statusIcon(session.status)} ${session.status}${metadata}`);
     console.log(export_pc.dim(transcriptPath));
     console.log("");
-    if (!existsSync17(transcriptPath)) {
+    if (!existsSync18(transcriptPath)) {
       process.stdout.write(export_pc.dim("Waiting for transcript..."));
       await new Promise((resolvePromise, rejectPromise) => {
         const poll = setInterval(() => {
-          if (!existsSync17(transcriptPath)) {
+          if (!existsSync18(transcriptPath)) {
             return;
           }
           clearInterval(poll);
@@ -172836,7 +173772,7 @@ ${export_pc.bold("Orbh Session Stats")} ${export_pc.dim("\xB7")} ${export_pc.cya
       const line = `${REQUEST_SPINNER_FRAMES[frame % REQUEST_SPINNER_FRAMES.length]} waiting for ${pending.length}/${resolvedIds.length} ${export_pc.dim("\xB7")} ${pendingLabel}`;
       process.stdout.write(`\r\x1B[2K${line}`);
       frame++;
-      await sleep2(250);
+      await sleep3(250);
     }
     let hasFailure = false;
     for (const fullId of resolvedIds) {
@@ -172929,7 +173865,10 @@ function registerLaunchCommands(command, options3) {
   });
   const interactiveCommand = options3.extendInteractiveCommand ? options3.extendInteractiveCommand(command.command("i")) : command.command("i");
   addOptionalPathOption(
-    interactiveCommand.alias("interactive").description("Launch an interactive agent TUI with orbh session tracking").argument("<target>", `Harness runtime or runtime/name (${listHarnesses().join(", ")})`).argument("[prompt]", "Optional initial prompt").option("-c, --continue <sessionId>", "Continue a previous orbh session").option("--continues <sessionId>", "Link as continuation of another session (new session)").option("--model <model>", "Model override"),
+    interactiveCommand.alias("interactive").description("Launch an interactive agent TUI with orbh session tracking").argument("<target>", `Harness runtime or runtime/name (${listHarnesses().join(", ")})`).argument("[prompt]", "Optional initial prompt").option("-c, --continue <sessionId>", "Continue a previous orbh session").option("--continues <sessionId>", "Link as continuation of another session (new session)").option("--model <model>", "Model override").option(
+      "--title-format <fmt>",
+      'Override the terminal pane title template. Default: "{title} {icon}" \u2014 orbh session title (`(Interactive) ` stripped) plus the harness status icon. Placeholders: {title}, {icon}, {inner}, {shortId}, {sessionId}, {runtime}, {cwd}. Falls back to $ORBH_TITLE_FORMAT.'
+    ),
     options3
   ).action(async (target, prompt6, commandOptions) => {
     const context = await getResolvedContext(commandOptions, options3);
@@ -172954,6 +173893,7 @@ function registerLaunchCommands(command, options3) {
       extraArgs,
       applicationPrompt: commandOptions.continue ? void 0 : options3.buildInteractiveApplicationPrompt,
       commandPath,
+      titleFormat: commandOptions.titleFormat,
       onPrepared: ({ session, run: run2 }) => {
         const resumed = Boolean(commandOptions.continue);
         console.log(`${export_pc.bold(resumed ? "Orbh Interactive Session (resumed)" : "Orbh Interactive Session")}`);
@@ -172995,7 +173935,7 @@ function registerServerCommands(command) {
       if (latest.running) {
         return latest;
       }
-      await sleep2(250);
+      await sleep3(250);
       latest = await getOrbhServerStatus(resolveServerConfigOptions(process.cwd(), opts));
     }
     return latest;
@@ -173041,7 +173981,7 @@ function registerServerCommands(command) {
     const daemonChild = process.env.ORBH_DAEMON_CHILD === "1";
     if (opts.daemon && !daemonChild) {
       const childArgs = process.argv.slice(1).filter((arg) => arg !== "--daemon");
-      const child = spawn8(process.argv[0] ?? process.execPath, childArgs, {
+      const child = spawn9(process.argv[0] ?? process.execPath, childArgs, {
         cwd: process.cwd(),
         detached: true,
         stdio: "ignore",
@@ -173132,7 +174072,7 @@ function registerServerCommands(command) {
         console.log(export_pc.green(`Orbh server stopped.`));
         return;
       }
-      await sleep2(250);
+      await sleep3(250);
     }
     console.error(export_pc.red(`Timed out waiting for orbh server PID ${status.pid} to stop.`));
     process.exit(1);
@@ -173168,7 +174108,7 @@ function registerOrbhCommands(command, options3) {
 }
 async function resolveStandaloneContext() {
   return {
-    sessionsDir: process.env.ORBH_SESSIONS_DIR ? resolvePath3(process.env.ORBH_SESSIONS_DIR) : join38(process.cwd(), ".orbh", "sessions"),
+    sessionsDir: process.env.ORBH_SESSIONS_DIR ? resolvePath3(process.env.ORBH_SESSIONS_DIR) : join39(process.cwd(), ".orbh", "sessions"),
     transcriptCwd: process.env.ORBH_CWD ? resolvePath3(process.env.ORBH_CWD) : process.cwd()
   };
 }
@@ -173180,7 +174120,7 @@ function createStandaloneOrbhCommand() {
   return command;
 }
 var __dirname5 = dirname12(fileURLToPath6(import.meta.url));
-var pkg2 = JSON.parse(readFileSync14(join38(__dirname5, "..", "package.json"), "utf-8"));
+var pkg2 = JSON.parse(readFileSync15(join39(__dirname5, "..", "package.json"), "utf-8"));
 function createStandaloneOrbhProgram() {
   return createStandaloneOrbhCommand().version(formatVersion(pkg2.version ?? "0.0.0", "orbh"));
 }
@@ -173191,7 +174131,7 @@ if (isDirectExecution) {
 
 // src/commands/agent/orbh.ts
 function getSessionsDir(flintPath) {
-  return join39(flintPath, ".orbh", "sessions");
+  return join40(flintPath, ".orbh", "sessions");
 }
 async function resolveFlintPath5(optionPath) {
   const flintPath = optionPath || await findFlintRoot(process.cwd());
@@ -173205,23 +174145,6 @@ async function resolveCtx(optionPath) {
   const flintPath = await resolveFlintPath5(optionPath);
   return { flintPath, sessionsDir: getSessionsDir(flintPath) };
 }
-function sessionReferencedInMesh(flintPath, sessionId) {
-  try {
-    execSync5(`grep -r "${sessionId}" "${join39(flintPath, "Mesh")}" --include="*.md" -l`, { stdio: "pipe", windowsHide: true });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function askYesNo(question) {
-  const rl = createInterface7({ input: process.stdin, output: process.stdout });
-  return new Promise((resolve19) => {
-    rl.question(question, (answer) => {
-      rl.close();
-      resolve19(answer.trim().toLowerCase() === "y" || answer.trim().toLowerCase() === "yes");
-    });
-  });
-}
 function escapeAppleScriptString(value) {
   return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\r?\n/g, " ");
 }
@@ -173238,54 +174161,6 @@ function sendNotification3(title, message) {
   } catch {
   }
 }
-function buildSessionFrontmatter(sessionId, runtime2) {
-  const now = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
-  const runtimeTag2 = runtime2 === "claude" ? "claude-code" : runtime2;
-  const runtimeTitle = runtime2 === "claude" ? "Claude Code" : runtime2.charAt(0).toUpperCase() + runtime2.slice(1);
-  return [
-    "---",
-    `id: ${sessionId}`,
-    "tags:",
-    '  - "#agent/session"',
-    `  - "#agent/${runtimeTag2}"`,
-    `date: ${now}`,
-    "---",
-    "",
-    `# ${runtimeTitle} Session`,
-    ""
-  ].join("\n");
-}
-function exportSessionTranscript(session, flintPath) {
-  const harness = getHarness(session.runtime);
-  if (!harness) {
-    return;
-  }
-  const run2 = getCurrentRun(session);
-  const nativeId = run2?.nativeSessionId ?? session.id;
-  const transcriptPath = harness.resolveTranscriptPath(nativeId, flintPath);
-  if (!transcriptPath) {
-    console.log(export_pc.dim("No transcript found to export."));
-    return;
-  }
-  let content;
-  try {
-    content = readFileSync15(transcriptPath, "utf-8");
-  } catch {
-    console.log(export_pc.dim("Could not read transcript file."));
-    return;
-  }
-  const entries = harness.parseTranscript(content, { transcriptPath });
-  if (entries.length === 0) {
-    console.log(export_pc.dim("Transcript is empty, skipping export."));
-    return;
-  }
-  const markdown2 = buildSessionFrontmatter(nativeId, session.runtime) + formatTranscriptMarkdown(entries);
-  const runtimeDir2 = session.runtime === "claude" ? "Claude Code" : session.runtime.charAt(0).toUpperCase() + session.runtime.slice(1);
-  const outputDir = join39(flintPath, "Mesh", "Agents", runtimeDir2);
-  mkdirSync4(outputDir, { recursive: true });
-  writeFileSync2(join39(outputDir, `${nativeId}.md`), markdown2, "utf-8");
-  console.log(export_pc.green(`Session exported \u2192 Mesh/Agents/${runtimeDir2}/${nativeId}.md`));
-}
 var orbhCommand = new Command("orbh").description("Orbh meta-harness agent management").enablePositionalOptions();
 registerOrbhCommands(orbhCommand, {
   commandPath: "flint orbh",
@@ -173336,28 +174211,7 @@ registerOrbhCommands(orbhCommand, {
     title: "(Interactive) New Session",
     description: "TBC"
   }),
-  extendInteractiveCommand: (command) => command.option("--dev-channels", "Load development MCP channels (e.g. orbh)").option("--no-export", "Skip transcript export on exit"),
-  onInteractiveExit: async ({ session, commandOptions }) => {
-    if (typeof commandOptions === "object" && commandOptions !== null && "export" in commandOptions && commandOptions.export === false) {
-      return;
-    }
-    const flintPath = await resolveFlintPath5(
-      typeof commandOptions === "object" && commandOptions !== null && "path" in commandOptions ? commandOptions.path : void 0
-    );
-    const nativeId = getCurrentRun(session)?.nativeSessionId ?? session.id;
-    try {
-      if (sessionReferencedInMesh(flintPath, session.id) || sessionReferencedInMesh(flintPath, nativeId)) {
-        exportSessionTranscript(session, flintPath);
-      } else {
-        const save = await askYesNo(export_pc.dim("Save session transcript? (y/N) "));
-        if (save) {
-          exportSessionTranscript(session, flintPath);
-        }
-      }
-    } catch (error3) {
-      console.error(export_pc.dim(`Transcript export failed: ${error3 instanceof Error ? error3.message : error3}`));
-    }
-  }
+  extendInteractiveCommand: (command) => command.option("--dev-channels", "Load development MCP channels (e.g. orbh)")
 });
 orbhCommand.command("artifact").description("Track a created artifact path in the session interface").argument("<id>", "Session ID (full or partial)").argument("<path>", "Path to the artifact").option("-p, --path <dir>", "Path to flint (default: auto-detect)").action(async (id, artifactPath, options3) => {
   const { sessionsDir } = await resolveCtx(options3.path);
@@ -173372,15 +174226,6 @@ orbhCommand.command("artifact").description("Track a created artifact path in th
   writeSession(sessionsDir, session);
   console.log(`Artifact tracked: ${artifactPath}`);
 });
-orbhCommand.command("export").description("Export a session transcript to Mesh/Agents/<Runtime>/").argument("<id>", "Session ID (full or partial)").option("-p, --path <dir>", "Path to flint (default: auto-detect)").action(async (id, options3) => {
-  const { flintPath, sessionsDir } = await resolveCtx(options3.path);
-  const session = resolveSession(sessionsDir, id);
-  if (!session) {
-    console.error(export_pc.red(`Error: Session not found: ${id}`));
-    process.exit(1);
-  }
-  exportSessionTranscript(session, flintPath);
-});
 orbhCommand.command("requests").description("View request/response pairs for a session").argument("<id>", "Session ID (full or partial)").option("-p, --path <dir>", "Path to flint (default: auto-detect)").option("--pending", "Show only unanswered requests").action(async (id, options3) => {
   const { sessionsDir } = await resolveCtx(options3.path);
   const session = resolveSession(sessionsDir, id);
@@ -173429,7 +174274,22 @@ ${export_pc.bold("Requests")} ${export_pc.dim(`\u2014 session ${shortId(session.
 });
 
 // src/commands/agent/tinderbox.ts
+import { stat as stat18 } from "fs/promises";
+import { join as join41 } from "path";
 init_dist4();
+async function pathExists6(path30) {
+  try {
+    await stat18(path30);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function deriveTinderboxNameFromGitUrl(url) {
+  const match2 = url.match(/[/:]([^/:]+?)(?:\.git)?\/?$/);
+  const raw = match2?.[1] ?? "";
+  return raw.replace(/^\(Tinderbox\)\s+/, "").trim();
+}
 async function requireTinderboxRoot() {
   const root = await findTinderboxRoot(process.cwd());
   if (!root) {
@@ -173438,6 +174298,21 @@ async function requireTinderboxRoot() {
   }
   return root;
 }
+function printObsidianRegistration(result) {
+  const newlyRegistered = result.registeredVaults.filter((entry) => !entry.alreadyRegistered);
+  if (newlyRegistered.length > 0) {
+    console.log(export_pc.bold("\nRegistered In Obsidian"));
+    for (const entry of newlyRegistered) {
+      console.log(`  ${export_pc.green("\u2713")} ${entry.name} ${export_pc.dim(`(id: ${entry.id})`)}`);
+    }
+  }
+  if (result.focusSwitched) {
+    console.log(export_pc.bold("\nFocus"));
+    console.log(
+      `  ${export_pc.green("\u2713")} ${result.focusSwitched.name} ${export_pc.dim(`(switched via NUU Obsidian plugin, id: ${result.focusSwitched.id})`)}`
+    );
+  }
+}
 function printSummary(result) {
   console.log(export_pc.bold("\nSummary"));
   console.log(`  Cloned: ${result.cloned.length}`);
@@ -173446,6 +174321,9 @@ function printSummary(result) {
   console.log(`  Already present: ${result.present.length}`);
   console.log(`  Registry updated: ${result.registryUpdated.length}`);
   console.log(`  Connections wired: ${result.connectionsWired.length}`);
+  console.log(
+    `  Obsidian vaults registered: ${result.registeredVaults.length}` + (result.focusSwitched ? ` (focused: ${result.focusSwitched.name})` : "")
+  );
   if (result.warnings.length > 0) {
     console.log(export_pc.bold(export_pc.yellow("\nWarnings")));
     for (const warning of result.warnings) {
@@ -173733,10 +174611,156 @@ Flints (${flints.length}):`));
       process.exit(1);
     }
   })
+).addCommand(
+  new Command("publish").description("Add a remote to the Tinderbox repo and push the initial commit").argument("<url>", "Git remote URL (e.g. git@github.com:owner/repo.git)").action(async (url) => {
+    const root = await requireTinderboxRoot();
+    try {
+      const { initialized } = await ensureTinderboxGitRepo(root);
+      console.log(
+        initialized ? export_pc.green("\u2713 Initialized git repository") : export_pc.dim("Git already initialized.")
+      );
+    } catch (err) {
+      console.error(export_pc.red(`Failed to initialize git: ${err instanceof Error ? err.message : String(err)}`));
+      process.exit(1);
+    }
+    const addRemote = await runGit(root, ["remote", "add", "origin", url]);
+    if (!addRemote.success) {
+      if (addRemote.error?.includes("already exists")) {
+        const setUrl = await runGit(root, ["remote", "set-url", "origin", url]);
+        if (!setUrl.success) {
+          console.error(export_pc.red(`Failed to update remote: ${setUrl.error}`));
+          process.exit(1);
+        }
+        console.log(export_pc.green(`\u2713 Updated remote origin \u2192 ${url}`));
+      } else {
+        console.error(export_pc.red(`Failed to add remote: ${addRemote.error}`));
+        process.exit(1);
+      }
+    } else {
+      console.log(export_pc.green(`\u2713 Added remote origin \u2192 ${url}`));
+    }
+    const renameBranch = await runGit(root, ["branch", "-M", "main"]);
+    if (!renameBranch.success) {
+      console.error(export_pc.red(`Failed to rename branch: ${renameBranch.error}`));
+      process.exit(1);
+    }
+    const hasCommits = await runGit(root, ["rev-parse", "HEAD"]);
+    if (!hasCommits.success) {
+      const add = await runGit(root, ["add", "-A"]);
+      if (!add.success) {
+        console.error(export_pc.red(`Failed to stage files: ${add.error}`));
+        process.exit(1);
+      }
+      const commit = await runGit(root, ["commit", "-m", "Initial tinderbox commit"]);
+      if (!commit.success) {
+        console.error(export_pc.red(`Failed to create initial commit: ${commit.error}`));
+        process.exit(1);
+      }
+      console.log(export_pc.green("\u2713 Created initial commit"));
+    } else {
+      const status = await getGitStatus(root);
+      if (!status.clean) {
+        const add = await runGit(root, ["add", "-A"]);
+        if (!add.success) {
+          console.error(export_pc.red(`Failed to stage files: ${add.error}`));
+          process.exit(1);
+        }
+        const now = /* @__PURE__ */ new Date();
+        const ts = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-${String(now.getDate()).padStart(2, "0")} ${String(now.getHours()).padStart(2, "0")}:${String(now.getMinutes()).padStart(2, "0")}`;
+        const commit = await runGit(root, ["commit", "-m", `tinderbox sync ${ts}`]);
+        if (!commit.success) {
+          console.error(export_pc.red(`Failed to commit: ${commit.error}`));
+          process.exit(1);
+        }
+        console.log(export_pc.green(`\u2713 Committed pending changes`));
+      }
+    }
+    const push = await runGit(root, ["push", "-u", "origin", "main"]);
+    if (!push.success) {
+      console.error(export_pc.red(`Push failed: ${push.error}`));
+      console.log(export_pc.dim("You can retry with: flint tinderbox git sync"));
+      process.exit(1);
+    }
+    console.log(export_pc.green("\u2713 Pushed to origin/main"));
+    console.log();
+    console.log(export_pc.bold("Tinderbox published. Use `flint tinderbox git sync` to keep in sync."));
+    console.log();
+  })
 );
 var tinderboxCommand = new Command("tinderbox").description("Orchestrate operations across multiple Flints").action(function() {
   this.help();
 }).addCommand(
+  new Command("init").description("Bootstrap an empty Tinderbox, or clone one from a git remote and sync").argument("[name]", "Tinderbox name (defaults to the repo basename when --from is given)").option("--from <url>", "Clone an existing Tinderbox from a git URL, then sync").option("--no-open", "Skip registering Flints in Obsidian and switching focus").action(async (nameArg, opts) => {
+    const cwd = process.cwd();
+    if (opts.from) {
+      const url = opts.from;
+      const name = (nameArg?.trim() || deriveTinderboxNameFromGitUrl(url)).trim();
+      if (!name) {
+        console.error(export_pc.red("Error: Could not derive a name from URL \u2014 pass <name> explicitly."));
+        process.exit(1);
+      }
+      const folderName = getTinderboxFolderNameForRoot(name);
+      const destination = join41(cwd, folderName);
+      if (await pathExists6(destination)) {
+        console.error(export_pc.red(`Error: Destination already exists: ${destination}`));
+        process.exit(1);
+      }
+      console.log(export_pc.dim(`Cloning ${url} \u2192 ${abbreviatePath(destination)}...`));
+      const clone = await runGit(cwd, ["clone", url, folderName]);
+      if (!clone.success) {
+        console.error(export_pc.red(`Clone failed: ${clone.error}`));
+        process.exit(1);
+      }
+      console.log(export_pc.green("\u2713 Cloned"));
+      if (!await pathExists6(join41(destination, "tinderbox.toml"))) {
+        console.error(export_pc.red("Error: Cloned repository is not a Tinderbox (missing tinderbox.toml)."));
+        console.log(export_pc.dim(`  ${destination}`));
+        process.exit(1);
+      }
+      console.log(export_pc.dim("\nSyncing declared Flints..."));
+      try {
+        const result = await syncTinderbox(destination, { obsidian: opts.open !== false });
+        printObsidianRegistration(result);
+        printSummary(result);
+        if (result.errors.length > 0) {
+          console.log(export_pc.bold(export_pc.red("\nErrors")));
+          for (const err of result.errors) {
+            console.log(`  ${export_pc.red("!")} ${export_pc.bold(err.scope)}: ${err.message}`);
+          }
+        }
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.error(export_pc.red(`Sync failed: ${message}`));
+        process.exit(1);
+      }
+      console.log();
+      console.log(export_pc.bold(`Tinderbox initialized from ${url}.`));
+      console.log(export_pc.dim(`  ${abbreviatePath(destination)}`));
+      console.log();
+      return;
+    }
+    const trimmedName = nameArg?.trim();
+    if (!trimmedName) {
+      console.error(export_pc.red("Error: <name> is required when --from is not provided."));
+      console.log(export_pc.dim("Usage: flint tinderbox init <name>"));
+      console.log(export_pc.dim("       flint tinderbox init [name] --from <url>"));
+      process.exit(1);
+    }
+    try {
+      const result = await initEmptyTinderbox(cwd, trimmedName);
+      console.log(export_pc.bold("\nTinderbox initialized"));
+      console.log(`  ${export_pc.green("\u2713")} ${export_pc.bold(trimmedName)} ${export_pc.dim(abbreviatePath(result.root))}`);
+      console.log();
+      console.log(export_pc.dim("  Empty Tinderbox created. Import Flints with `flint tinderbox import <name>` or edit tinderbox.toml."));
+      console.log(export_pc.dim("  Publish to a remote with `flint tinderbox git publish <url>`."));
+      console.log();
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.error(export_pc.red(`Error: ${message}`));
+      process.exit(1);
+    }
+  })
+).addCommand(
   new Command("start").description("Promote the current Flint into a new Tinderbox").argument("<name>", "Tinderbox name").argument("[path]", "Parent directory for the new Tinderbox (defaults to the current Flint's parent)").action(async (name, path30) => {
     try {
       const cwd = process.cwd();
@@ -173746,7 +174770,7 @@ var tinderboxCommand = new Command("tinderbox").description("Orchestrate operati
       console.log(`  ${export_pc.green("\u2713")} ${export_pc.bold(name)} ${export_pc.dim(abbreviatePath(result.root))}`);
       console.log(`  ${export_pc.green("\u2713")} Moved ${export_pc.bold(result.flintMoved.name)} ${export_pc.dim(`${abbreviatePath(result.flintMoved.from)} \u2192 ${abbreviatePath(result.flintMoved.to)}`)}`);
       console.log();
-      console.log(export_pc.dim("  Tinderbox is now a git repository. Add a remote with `git remote add origin <url>` from the Tinderbox root."));
+      console.log(export_pc.dim("  Tinderbox is now a git repository. Publish to a remote with `flint tinderbox git publish <url>`."));
       console.log();
     } catch (error3) {
       const message = error3 instanceof Error ? error3.message : String(error3);
@@ -173776,10 +174800,10 @@ var tinderboxCommand = new Command("tinderbox").description("Orchestrate operati
     }
   })
 ).addCommand(
-  new Command("sync").description("Materialize Flints, register them, and wire connections").action(async () => {
+  new Command("sync").description("Materialize Flints, register them, and wire connections").option("--no-open", "Skip registering Flints in Obsidian and switching focus").action(async (opts) => {
     try {
       const root = await requireTinderboxRoot();
-      const result = await syncTinderbox(root);
+      const result = await syncTinderbox(root, { obsidian: opts.open !== false });
       if (result.cloned.length > 0) {
         console.log(export_pc.bold("\nCloned"));
         for (const name of result.cloned) {
@@ -173804,6 +174828,7 @@ var tinderboxCommand = new Command("tinderbox").description("Orchestrate operati
           console.log(`  ${export_pc.green("\u2713")} ${edge.from} -> ${edge.to}`);
         }
       }
+      printObsidianRegistration(result);
       printSummary(result);
       if (result.undeclared.length > 0) {
         console.log(export_pc.bold(export_pc.yellow("Undeclared Flints (on disk but not in config)")));
@@ -173936,11 +174961,11 @@ var tinderboxCommand = new Command("tinderbox").description("Orchestrate operati
 init_dist4();
 import { createRequire as createRequire2 } from "module";
 import path28 from "path";
-import { spawn as spawn10 } from "child_process";
-import { stat as stat19 } from "fs/promises";
+import { spawn as spawn11 } from "child_process";
+import { stat as stat20 } from "fs/promises";
 
 // ../../packages/flint-sdk/src/common.ts
-function isRecord10(value) {
+function isRecord11(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 async function parseErrorBody(response) {
@@ -173948,7 +174973,7 @@ async function parseErrorBody(response) {
   try {
     if (contentType.includes("application/json")) {
       const data = await response.json();
-      return isRecord10(data) ? data : null;
+      return isRecord11(data) ? data : null;
     }
     const text = await response.text();
     return text ? { message: text } : null;
@@ -174548,12 +175573,12 @@ var FlintServerClient = class {
 
 // ../../packages/flint-sdk/src/discovery.ts
 async function loadNodeModules() {
-  const [{ readFile: readFile18 }, { homedir: homedir11 }, { join: join49, resolve: resolve19 }] = await Promise.all([
+  const [{ readFile: readFile18 }, { homedir: homedir12 }, { join: join51, resolve: resolve19 }] = await Promise.all([
     import("fs/promises"),
     import("os"),
     import("path")
   ]);
-  return { readFile: readFile18, homedir: homedir11, join: join49, resolve: resolve19 };
+  return { readFile: readFile18, homedir: homedir12, join: join51, resolve: resolve19 };
 }
 function normalizeRegistryFile(value) {
   if (!value || typeof value !== "object" || !("servers" in value) || !Array.isArray(value.servers)) {
@@ -174569,12 +175594,12 @@ function normalizeRegistryFile(value) {
   return { version: 1, servers };
 }
 async function getServerRegistryPathCandidates(homeDir) {
-  const { homedir: homedir11, join: join49 } = await loadNodeModules();
-  const root = homeDir ?? homedir11();
+  const { homedir: homedir12, join: join51 } = await loadNodeModules();
+  const root = homeDir ?? homedir12();
   return [
-    join49(root, ".nuucognition", "servers.json"),
-    join49(root, ".nuucognition", ".flint", "servers.json"),
-    join49(root, ".flint", "servers.json")
+    join51(root, ".nuucognition", "servers.json"),
+    join51(root, ".nuucognition", ".flint", "servers.json"),
+    join51(root, ".flint", "servers.json")
   ];
 }
 async function readServerRegistryFile(options3 = {}) {
@@ -174609,9 +175634,9 @@ import { fileURLToPath as fileURLToPath7 } from "url";
 import { join as join54 } from "path";
 import { readdirSync as readdirSync22, existsSync as existsSync43 } from "fs";
 import { randomUUID as randomUUID9, createHash as createHash3 } from "crypto";
-import { EventEmitter as EventEmitter2 } from "events";
-import { readFile as readFile16, stat as stat18 } from "fs/promises";
-import { spawn as spawn9 } from "child_process";
+import { EventEmitter as EventEmitter3 } from "events";
+import { readFile as readFile16, stat as stat19 } from "fs/promises";
+import { spawn as spawn10 } from "child_process";
 import path26 from "path";
 import chokidar from "chokidar";
 import { glob } from "glob";
@@ -176152,12 +177177,12 @@ minimatch.unescape = unescape2;
 // ../../packages/flint-server/dist/index.js
 init_dist();
 import { parse as parseYaml6 } from "yaml";
-import { existsSync as existsSync18, watch as watch4 } from "fs";
+import { existsSync as existsSync19, watch as watch4 } from "fs";
 import { stat as stat25 } from "fs/promises";
 import path27 from "path";
 import { mkdir as mkdir18, readFile as readFile27, writeFile as writeFile14 } from "fs/promises";
-import { homedir as homedir10 } from "os";
-import { join as join40, resolve as resolve18 } from "path";
+import { homedir as homedir11 } from "os";
+import { join as join46, resolve as resolve18 } from "path";
 init_dist4();
 init_dist4();
 init_dist4();
@@ -176166,7 +177191,7 @@ import { existsSync as existsSync24 } from "fs";
 import { stat as stat33, readFile as readFile37 } from "fs/promises";
 import path33 from "path";
 import path43, { join as join211 } from "path";
-import { readdirSync as readdirSync8, readFileSync as readFileSync16, existsSync as existsSync33 } from "fs";
+import { readdirSync as readdirSync9, readFileSync as readFileSync16, existsSync as existsSync33 } from "fs";
 import { readdir as readdir15 } from "fs/promises";
 import path53 from "path";
 import { readdir as readdir25 } from "fs/promises";
@@ -176174,7 +177199,7 @@ import { join as join310 } from "path";
 import { mkdir as mkdir25, readFile as readFile43, rename as rename10, writeFile as writeFile26, readdir as readdir33 } from "fs/promises";
 import path62 from "path";
 import { writeFile as writeFile35, mkdir as mkdir33, readdir as readdir43, readFile as readFile53, stat as stat43 } from "fs/promises";
-import { join as join46 } from "path";
+import { join as join47 } from "path";
 var DEFAULT_EVENT_LOG_SIZE = 200;
 function computeRuntimeId(flintPath) {
   const resolved = path26.resolve(flintPath);
@@ -176189,7 +177214,7 @@ var FlintRuntimeImpl = class {
   hooksPath;
   logger;
   eventLogSize;
-  emitter = new EventEmitter2();
+  emitter = new EventEmitter3();
   watcher = null;
   hooksConfig = { hooks: {} };
   eventLog = [];
@@ -176471,7 +177496,7 @@ function normalizePath2(filePath) {
 }
 async function safeReadFile(filePath) {
   try {
-    const fileStats = await stat18(filePath);
+    const fileStats = await stat19(filePath);
     if (!fileStats.isFile()) {
       return null;
     }
@@ -176571,7 +177596,7 @@ async function executeHook(options3) {
       path26.join(process.cwd(), "node_modules", ".bin"),
       process.env.PATH
     ].filter(Boolean);
-    const child = spawn9(command, {
+    const child = spawn10(command, {
       cwd: flintPath,
       env: {
         ...process.env,
@@ -176755,7 +177780,7 @@ function createResilientWatcher({
     if (closed) {
       return;
     }
-    if (!existsSync18(targetPath)) {
+    if (!existsSync19(targetPath)) {
       scheduleRestart();
       return;
     }
@@ -176818,9 +177843,9 @@ var RuntimeManager = class {
     }));
   }
 };
-var REGISTRY_PATH = join40(homedir10(), ".nuucognition", "servers.json");
+var REGISTRY_PATH = join46(homedir11(), ".nuucognition", "servers.json");
 function getRegistryDir() {
-  return join40(homedir10(), ".nuucognition");
+  return join46(homedir11(), ".nuucognition");
 }
 async function readServerRegistry() {
   return readServerRegistryEntries({ registryPath: REGISTRY_PATH });
@@ -177421,7 +178446,7 @@ async function buildFlintIdentity(ctx) {
   let totalSessions = 0;
   let activeSessions = 0;
   if (ctx.orbhSessionsDir && existsSync33(ctx.orbhSessionsDir)) {
-    const files = readdirSync8(ctx.orbhSessionsDir).filter((f) => f.endsWith(".json"));
+    const files = readdirSync9(ctx.orbhSessionsDir).filter((f) => f.endsWith(".json"));
     totalSessions = files.length;
     for (const file of files) {
       try {
@@ -178084,7 +179109,7 @@ var LiveTranscriptWriter = class {
   writtenPaths = /* @__PURE__ */ new Set();
   constructor(options3) {
     this.flintPath = options3.flintPath;
-    this.sessionsDir = join46(options3.flintPath, ".orbh", "sessions");
+    this.sessionsDir = join47(options3.flintPath, ".orbh", "sessions");
     this.channelRegistry = options3.channelRegistry;
     this.suppressPath = options3.suppressPath ?? null;
     this.liveSessionManager = new LiveSessionManager({
@@ -178133,7 +179158,7 @@ var LiveTranscriptWriter = class {
    * but whose session is no longer in-progress.
    */
   async sweepOrphans() {
-    const agentsDir = join46(this.flintPath, "Mesh", "Agents");
+    const agentsDir = join47(this.flintPath, "Mesh", "Agents");
     let runtimeDirs;
     try {
       runtimeDirs = await readdir43(agentsDir);
@@ -178141,7 +179166,7 @@ var LiveTranscriptWriter = class {
       return;
     }
     for (const dir of runtimeDirs) {
-      const dirPath = join46(agentsDir, dir);
+      const dirPath = join47(agentsDir, dir);
       const dirStat = await stat43(dirPath).catch(() => null);
       if (!dirStat?.isDirectory()) continue;
       let files;
@@ -178152,7 +179177,7 @@ var LiveTranscriptWriter = class {
       }
       for (const file of files) {
         if (!file.endsWith(".md")) continue;
-        const filePath = join46(dirPath, file);
+        const filePath = join47(dirPath, file);
         let content;
         try {
           content = await readFile53(filePath, "utf-8");
@@ -178220,8 +179245,8 @@ var LiveTranscriptWriter = class {
   }
   async writeTranscript(sessionId, session, entries, live) {
     const dir = runtimeDir(session.runtime);
-    const outputDir = join46(this.flintPath, "Mesh", "Agents", dir);
-    const outputPath = join46(outputDir, `${sessionId}.md`);
+    const outputDir = join47(this.flintPath, "Mesh", "Agents", dir);
+    const outputPath = join47(outputDir, `${sessionId}.md`);
     try {
       await mkdir33(outputDir, { recursive: true });
       const frontmatter = buildLiveFrontmatter(session, live);
@@ -178643,7 +179668,7 @@ serverCommand.command("dev").description(
   }
   const devEntry = path28.join(serverPkgDir, "src", "dev.ts");
   try {
-    await stat19(devEntry);
+    await stat20(devEntry);
   } catch {
     console.error(export_pc.red("Dev mode requires the server source directory."));
     console.log(
@@ -178665,7 +179690,7 @@ serverCommand.command("dev").description(
     `${export_pc.bold(export_pc.blue("Flint Server"))} ${export_pc.dim("dev mode \u2014 watching for changes")}
 `
   );
-  const child = spawn10("tsx", ["watch", devEntry], {
+  const child = spawn11("tsx", ["watch", devEntry], {
     env: env3,
     stdio: "inherit",
     cwd: serverPkgDir,
@@ -178762,11 +179787,11 @@ serverCommand.command("list").description("List all running Flint servers from t
 // src/commands/server/steel.ts
 init_dist4();
 import { readFile as readFile17, readdir as readdir16, rm as rm14 } from "fs/promises";
-import { join as join41 } from "path";
+import { join as join48 } from "path";
 async function exists6(path30) {
   try {
-    const { stat: stat20 } = await import("fs/promises");
-    await stat20(path30);
+    const { stat: stat21 } = await import("fs/promises");
+    await stat21(path30);
     return true;
   } catch {
     return false;
@@ -178788,7 +179813,7 @@ var steelCommand = new Command("steel").description("Manage Steel UI state (.ste
         console.error(export_pc.red("Error: Not inside a Flint. Use --path or cd into a Flint."));
         process.exit(1);
       }
-      const prefsPath = join41(flintPath, ".steel", "preferences.json");
+      const prefsPath = join48(flintPath, ".steel", "preferences.json");
       if (options3.reset) {
         if (await exists6(prefsPath)) {
           await rm14(prefsPath);
@@ -178818,7 +179843,7 @@ var steelCommand = new Command("steel").description("Manage Steel UI state (.ste
         console.error(export_pc.red("Error: Not inside a Flint. Use --path or cd into a Flint."));
         process.exit(1);
       }
-      const plateDir = join41(flintPath, ".steel", "plates", plateName);
+      const plateDir = join48(flintPath, ".steel", "plates", plateName);
       if (options3.reset) {
         if (await exists6(plateDir)) {
           await rm14(plateDir, { recursive: true });
@@ -178842,7 +179867,7 @@ var steelCommand = new Command("steel").description("Manage Steel UI state (.ste
       console.log();
       for (const file of stateFiles) {
         const key = file.name.replace(/\.json$/, "");
-        const data = await readJsonFile2(join41(plateDir, file.name));
+        const data = await readJsonFile2(join48(plateDir, file.name));
         console.log(`${export_pc.cyan(key)}:`);
         console.log(JSON.stringify(data, null, 2));
         console.log();
@@ -178861,7 +179886,7 @@ var steelCommand = new Command("steel").description("Manage Steel UI state (.ste
         console.error(export_pc.red("Error: Not inside a Flint. Use --path or cd into a Flint."));
         process.exit(1);
       }
-      const boardsDir = join41(flintPath, ".steel", "plates", plateName, "boards");
+      const boardsDir = join48(flintPath, ".steel", "plates", plateName, "boards");
       if (!await exists6(boardsDir)) {
         console.log(export_pc.dim(`No board configs found for plate: ${plateName}`));
         return;
@@ -179257,8 +180282,8 @@ var iamCommand = new Command("iam").argument("<name>", 'Person name to set as id
 init_dist4();
 
 // src/commands/system/helper/_shared.ts
-import { readdirSync as readdirSync9, existsSync as existsSync19, statSync as statSync7 } from "fs";
-import { join as join47, basename as basename10 } from "path";
+import { readdirSync as readdirSync10, existsSync as existsSync20, statSync as statSync8 } from "fs";
+import { join as join49, basename as basename10 } from "path";
 function extractNumberFromFile(filename, typeName) {
   const regex3 = new RegExp(`^\\(${typeName}\\)\\s+(\\d+)`, "i");
   const match2 = filename.match(regex3);
@@ -179266,13 +180291,13 @@ function extractNumberFromFile(filename, typeName) {
 }
 function collectFilesRecursively(dirPath) {
   const files = [];
-  if (!existsSync19(dirPath)) return files;
-  for (const entry of readdirSync9(dirPath)) {
-    const fullPath = join47(dirPath, entry);
+  if (!existsSync20(dirPath)) return files;
+  for (const entry of readdirSync10(dirPath)) {
+    const fullPath = join49(dirPath, entry);
     try {
-      const stat20 = statSync7(fullPath);
-      if (stat20.isDirectory()) files.push(...collectFilesRecursively(fullPath));
-      else if (stat20.isFile()) files.push(basename10(fullPath));
+      const stat21 = statSync8(fullPath);
+      if (stat21.isDirectory()) files.push(...collectFilesRecursively(fullPath));
+      else if (stat21.isFile()) files.push(basename10(fullPath));
     } catch {
       continue;
     }
@@ -179280,8 +180305,8 @@ function collectFilesRecursively(dirPath) {
   return files;
 }
 function getNextNumber(flintPath, typeName) {
-  const meshDir = join47(flintPath, "Mesh");
-  if (!existsSync19(meshDir)) return 1;
+  const meshDir = join49(flintPath, "Mesh");
+  if (!existsSync20(meshDir)) return 1;
   const numbers = collectFilesRecursively(meshDir).map((f) => extractNumberFromFile(f, typeName)).filter((n) => n !== null);
   return numbers.length === 0 ? 1 : Math.max(...numbers) + 1;
 }
@@ -179470,7 +180495,7 @@ var whoamiCommand = new Command("whoami").description("Show the current person i
 // src/index.ts
 registerAllFeatures();
 var __dirname6 = dirname13(fileURLToPath8(import.meta.url));
-var pkg3 = JSON.parse(readFileSync17(join48(__dirname6, "..", "package.json"), "utf-8"));
+var pkg3 = JSON.parse(readFileSync17(join50(__dirname6, "..", "package.json"), "utf-8"));
 var profile = getBuildMode("flint");
 await runCliMigrations({
   cliname: "flint",
@@ -179511,7 +180536,7 @@ program2.name("flint").description("Flint cognitive workspace CLI").version(form
 setCommandGroups(program2, [
   {
     label: "Flint",
-    commands: ["init", "list", "status", "open", "register", "unregister", "delete", "move", "sync", "plan", "registry", "update"]
+    commands: ["init", "list", "status", "open", "register", "unregister", "delete", "move", "sync", "gigasync", "plan", "registry", "update"]
   },
   {
     label: "Related Entities",
@@ -179555,6 +180580,7 @@ var COMMAND_MAP = [
   { featureId: "list", command: listCommand },
   { featureId: "shard", command: shardCommand },
   { featureId: "sync", command: syncCommand },
+  { featureId: "gigasync", command: gigasyncCommand },
   { featureId: "git", command: gitCommand },
   { featureId: "open", command: openCommand },
   { featureId: "register", command: registerCommand },