@nuucognition/flint-cli 0.6.0-dev.0 → 0.6.0-dev.1

package/dist/index.js

@@ -455,8 +455,8 @@ var init_parseUtil = __esm({
     init_errors();
     init_en();
     makeIssue = (params) => {
-      const { data, path: path29, errorMaps, issueData } = params;
-      const fullPath = [...path29, ...issueData.path || []];
+      const { data, path: path30, errorMaps, issueData } = params;
+      const fullPath = [...path30, ...issueData.path || []];
       const fullIssue = {
         ...issueData,
         path: fullPath
@@ -767,11 +767,11 @@ var init_types = __esm({
     init_parseUtil();
     init_util();
     ParseInputLazyPath = class {
-      constructor(parent, value, path29, key) {
+      constructor(parent, value, path30, key) {
         this._cachedPath = [];
         this.parent = parent;
         this.data = value;
-        this._path = path29;
+        this._path = path30;
         this._key = key;
       }
       get path() {
@@ -5117,9 +5117,9 @@ async function readLocalState(flintPath) {
   }
 }
 async function writeLocalState(flintPath, state) {
-  const path29 = getLocalStatePath(flintPath);
-  await mkdir2(dirname4(path29), { recursive: true });
-  await writeFile2(path29, JSON.stringify(state, null, 2) + "\n");
+  const path30 = getLocalStatePath(flintPath);
+  await mkdir2(dirname4(path30), { recursive: true });
+  await writeFile2(path30, JSON.stringify(state, null, 2) + "\n");
 }
 async function getLocalFlintVersion(flintPath) {
   const state = await readLocalState(flintPath);
@@ -5168,8 +5168,8 @@ function parseWorkspaceToml(content) {
   }
   return config;
 }
-function generateReferenceMarkdown(path29) {
-  return `**Path:** ${path29}
+function generateReferenceMarkdown(path30) {
+  return `**Path:** ${path30}
 **Type:** codebase
 
 ## Key Paths
@@ -5181,9 +5181,9 @@ function generateReferenceMarkdown(path29) {
 (add notes here)
 `;
 }
-async function isDirectory(path29) {
+async function isDirectory(path30) {
   try {
-    const s = await stat(path29);
+    const s = await stat(path30);
     return s.isDirectory();
   } catch {
     return false;
@@ -5225,17 +5225,17 @@ async function readFlintJson(flintPath) {
 async function writeFlintJsonFile(flintPath, data) {
   await writeFile22(join32(flintPath, FLINT_JSON), JSON.stringify(data, null, 2) + "\n");
 }
-async function isDirectory2(path29) {
+async function isDirectory2(path30) {
   try {
-    const s = await stat3(path29);
+    const s = await stat3(path30);
     return s.isDirectory();
   } catch {
     return false;
   }
 }
-async function fileExists(path29) {
+async function fileExists(path30) {
   try {
-    await stat3(path29);
+    await stat3(path30);
     return true;
   } catch {
     return false;
@@ -5358,16 +5358,16 @@ async function readFlintJson2(flintPath) {
 async function writeFlintJsonFile2(flintPath, data) {
   await writeFile32(join6(flintPath, FLINT_JSON2), JSON.stringify(data, null, 2) + "\n");
 }
-async function pathExists(path29) {
+async function pathExists(path30) {
   try {
-    await stat6(path29);
+    await stat6(path30);
     return true;
   } catch {
     return false;
   }
 }
-async function ensureDir(path29) {
-  await mkdir42(path29, { recursive: true });
+async function ensureDir(path30) {
+  await mkdir42(path30, { recursive: true });
 }
 function toKebabCase(name) {
   return name.replace(/\([^)]*\)\s*/g, "").toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "").replace(/^-+|-+$/g, "");
@@ -5627,11 +5627,11 @@ async function renameDeclaredRepoFolders(ctx, baseDir, repositories, changes, wa
     changes.push(`Renamed ${baseDir}/${legacyName} \u2192 ${baseDir}/${repo.name}`);
   }
 }
-async function removeDirIfEmpty(path29) {
+async function removeDirIfEmpty(path30) {
   try {
-    const entries = await readdir6(path29);
+    const entries = await readdir6(path30);
     if (entries.length === 0) {
-      await rmdir(path29);
+      await rmdir(path30);
     }
   } catch {
   }
@@ -6377,24 +6377,24 @@ function createMigrationContext(flintPath, options3 = {}) {
     log,
     warn,
     error: error3,
-    async exists(path29) {
+    async exists(path30) {
       try {
-        await access2(resolve18(path29));
+        await access2(resolve18(path30));
         return true;
       } catch {
         return false;
       }
     },
-    async read(path29) {
-      return readFile6(resolve18(path29), "utf-8");
+    async read(path30) {
+      return readFile6(resolve18(path30), "utf-8");
     },
-    async write(path29, content) {
-      const fullPath = resolve18(path29);
+    async write(path30, content) {
+      const fullPath = resolve18(path30);
       await mkdir6(dirname22(fullPath), { recursive: true });
       await writeFile5(fullPath, content, "utf-8");
     },
-    async delete(path29) {
-      await unlink2(resolve18(path29));
+    async delete(path30) {
+      await unlink2(resolve18(path30));
     },
     // ── Intent (flint.toml) ──────────────────────────────────────────────
     async readIntentText() {
@@ -6432,14 +6432,14 @@ function createMigrationContext(flintPath, options3 = {}) {
         await mkdir6(dirname22(dest), { recursive: true });
         await rename6(resolve18(from), dest);
       },
-      async rm(path29, options22) {
-        await fsRm(resolve18(path29), { recursive: options22?.recursive ?? false, force: true });
+      async rm(path30, options22) {
+        await fsRm(resolve18(path30), { recursive: options22?.recursive ?? false, force: true });
       },
-      async mkdir(path29, options22) {
-        await mkdir6(resolve18(path29), { recursive: options22?.recursive ?? true });
+      async mkdir(path30, options22) {
+        await mkdir6(resolve18(path30), { recursive: options22?.recursive ?? true });
       },
-      async readDir(path29) {
-        return readdir9(resolve18(path29));
+      async readDir(path30) {
+        return readdir9(resolve18(path30));
       }
     }
   };
@@ -8417,8 +8417,8 @@ async function findFlintRoot(startPath) {
   }
   return null;
 }
-async function isInsideFlint(path29) {
-  const flintRoot = await findFlintRoot(path29);
+async function isInsideFlint(path30) {
+  const flintRoot = await findFlintRoot(path30);
   return flintRoot !== null;
 }
 function getTypePrefix() {
@@ -8511,9 +8511,9 @@ function isDevShard(decl) {
   const mode = resolveShardMode(decl);
   return mode === "dev-remote" || mode === "dev-local";
 }
-async function exists(path29) {
+async function exists(path30) {
   try {
-    await stat22(path29);
+    await stat22(path30);
     return true;
   } catch {
     return false;
@@ -9661,9 +9661,9 @@ var init_chunk_DM3D33H6 = __esm({
 
 // ../../packages/flint/dist/chunk-STM4NXTT.js
 import { access as access3 } from "fs/promises";
-async function exists2(path29) {
+async function exists2(path30) {
   try {
-    await access3(path29);
+    await access3(path30);
     return true;
   } catch {
     return false;
@@ -9766,51 +9766,51 @@ function isRecord(value) {
 function isNonEmptyString(value) {
   return typeof value === "string" && value.trim().length > 0;
 }
-function addIssue(issues, path29, message) {
-  issues.push(`Invalid "${path29}": ${message}`);
+function addIssue(issues, path30, message) {
+  issues.push(`Invalid "${path30}": ${message}`);
 }
-function validateString(value, path29, issues, options3 = {}) {
+function validateString(value, path30, issues, options3 = {}) {
   if (value === void 0) {
     if (options3.required) {
-      issues.push(`Missing required field "${path29}"`);
+      issues.push(`Missing required field "${path30}"`);
     }
     return void 0;
   }
   if (!isNonEmptyString(value)) {
-    addIssue(issues, path29, "expected a non-empty string");
+    addIssue(issues, path30, "expected a non-empty string");
     return void 0;
   }
   if (options3.exact && value !== options3.exact) {
-    addIssue(issues, path29, `expected "${options3.exact}", got "${value}"`);
+    addIssue(issues, path30, `expected "${options3.exact}", got "${value}"`);
     return void 0;
   }
   if (options3.singleLine && /\r|\n/.test(value)) {
-    addIssue(issues, path29, "expected a single-line string");
+    addIssue(issues, path30, "expected a single-line string");
     return void 0;
   }
   if (options3.pattern && !options3.pattern.test(value)) {
-    addIssue(issues, path29, options3.patternDescription ?? `expected to match ${options3.pattern}`);
+    addIssue(issues, path30, options3.patternDescription ?? `expected to match ${options3.pattern}`);
     return void 0;
   }
   return value;
 }
-function validateStringArray(value, path29, issues) {
+function validateStringArray(value, path30, issues) {
   if (value === void 0) return void 0;
   if (!Array.isArray(value)) {
-    addIssue(issues, path29, "expected an array of strings");
+    addIssue(issues, path30, "expected an array of strings");
     return void 0;
   }
   const items = [];
   value.forEach((entry, index) => {
-    const item = validateString(entry, `${path29}[${index}]`, issues);
+    const item = validateString(entry, `${path30}[${index}]`, issues);
     if (item !== void 0) {
       items.push(item);
     }
   });
   return items;
 }
-function validateNodeScriptPath(value, path29, issues, options3 = {}) {
-  const validated = validateString(value, path29, issues, {
+function validateNodeScriptPath(value, path30, issues, options3 = {}) {
+  const validated = validateString(value, path30, issues, {
     required: options3.required,
     singleLine: true
   });
@@ -9818,19 +9818,19 @@ function validateNodeScriptPath(value, path29, issues, options3 = {}) {
     return void 0;
   }
   if (validated.startsWith("/") || validated.startsWith("\\")) {
-    addIssue(issues, path29, "expected a relative path inside the shard");
+    addIssue(issues, path30, "expected a relative path inside the shard");
     return void 0;
   }
   if (validated.split(/[\\/]+/).some((segment) => segment === "..")) {
-    addIssue(issues, path29, "path traversal is not allowed");
+    addIssue(issues, path30, "path traversal is not allowed");
     return void 0;
   }
   if (!validated.endsWith(".js")) {
-    addIssue(issues, path29, 'expected a Node.js ".js" file');
+    addIssue(issues, path30, 'expected a Node.js ".js" file');
     return void 0;
   }
   if (options3.prefix && !validated.startsWith(`${options3.prefix}/`)) {
-    addIssue(issues, path29, `expected a path under "${options3.prefix}/"`);
+    addIssue(issues, path30, `expected a path under "${options3.prefix}/"`);
     return void 0;
   }
   return validated;
@@ -10054,8 +10054,8 @@ function normalizeLegacyManifest(raw, _context) {
     install
   };
 }
-function addWarning(warnings, path29, message) {
-  warnings.push(`"${path29}": ${message}`);
+function addWarning(warnings, path30, message) {
+  warnings.push(`"${path30}": ${message}`);
 }
 function parseShardManifestContent(content, manifestPath) {
   let parsed;
@@ -10627,9 +10627,9 @@ function classifyGitError(error3) {
   }
   return "unknown";
 }
-async function pathExists3(path29) {
+async function pathExists3(path30) {
   try {
-    await stat23(path29);
+    await stat23(path30);
     return true;
   } catch {
     return false;
@@ -11182,8 +11182,8 @@ async function updateShardLocalStateSetup(flintPath, name, shorthand, setup) {
   await syncSetupStateFile(getShardLocalStatePath(flintPath, name), shorthand, setup, { setup });
 }
 async function getShardSetupState(flintPath, name) {
-  const readLayer = async (path29) => {
-    const snap = await readSetupStateFileSnapshot(path29, "required");
+  const readLayer = async (path30) => {
+    const snap = await readSetupStateFileSnapshot(path30, "required");
     return snap ? { exists: true, setup: snap.setup } : { exists: false, setup: null };
   };
   return {
@@ -11193,8 +11193,8 @@ async function getShardSetupState(flintPath, name) {
 }
 async function setShardSetupState(flintPath, name, shorthand, scope, setup) {
   await ensureShardSystemFolders(flintPath);
-  const path29 = scope === "flint" ? getShardStatePath(flintPath, name) : getShardLocalStatePath(flintPath, name);
-  await syncSetupStateFile(path29, shorthand, setup, { setup });
+  const path30 = scope === "flint" ? getShardStatePath(flintPath, name) : getShardLocalStatePath(flintPath, name);
+  await syncSetupStateFile(path30, shorthand, setup, { setup });
 }
 function processTemplate(content) {
   const now = /* @__PURE__ */ new Date();
@@ -14106,42 +14106,44 @@ import { randomUUID as randomUUID22 } from "crypto";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { stat as stat82 } from "fs/promises";
 import { join as join142 } from "path";
+import path22 from "path";
+import { fileURLToPath as fileURLToPath22 } from "url";
 import { readdir as readdir92, readFile as readFile82, mkdir as mkdir12, writeFile as writeFile82, rm as rm62, stat as stat92, copyFile as copyFile2 } from "fs/promises";
 import { join as join152, basename as basename5, dirname as dirname52, resolve as resolve6, relative as relative3, sep as sep3, extname as extname2 } from "path";
 import { promises as fs42 } from "fs";
-import path42 from "path";
+import path52 from "path";
 import { promises as fs22 } from "fs";
-import path22 from "path";
-import { promises as fs32 } from "fs";
 import path32 from "path";
+import { promises as fs32 } from "fs";
+import path42 from "path";
 import { promises as fs52 } from "fs";
-import path52 from "path";
 import path6 from "path";
+import path7 from "path";
 import { randomUUID as randomUUID32 } from "crypto";
 import { promises as fs72 } from "fs";
-import path7 from "path";
 import path8 from "path";
-import { promises as fs8 } from "fs";
 import path9 from "path";
+import { promises as fs8 } from "fs";
 import path10 from "path";
 import path11 from "path";
+import path12 from "path";
 import { exec as exec5 } from "child_process";
 import { promises as fs9 } from "fs";
-import path12 from "path";
+import path13 from "path";
 import { promisify as promisify62 } from "util";
 import { promises as fs10 } from "fs";
-import path13 from "path";
-import { promises as fs11 } from "fs";
 import path14 from "path";
-import { promises as fs12 } from "fs";
+import { promises as fs11 } from "fs";
 import path15 from "path";
-import { promises as fs13 } from "fs";
+import { promises as fs12 } from "fs";
 import path16 from "path";
-import { promises as fs14 } from "fs";
+import { promises as fs13 } from "fs";
 import path17 from "path";
+import { promises as fs14 } from "fs";
+import path18 from "path";
 import { exec as exec6 } from "child_process";
 import { promises as fs15 } from "fs";
-import path18 from "path";
+import path19 from "path";
 import { promisify as promisify72 } from "util";
 function formatFlintFolderName(name) {
   const prefix = getTypePrefix();
@@ -14228,20 +14230,20 @@ Create notes in \`Mesh/\` and link them with \`[[wiki-links]]\`.
 async function createMediaDir(flintPath) {
   await mkdir24(join25(flintPath, "Media"), { recursive: true });
 }
-async function isValidFlint(path192) {
+async function isValidFlint(path202) {
   try {
-    const stats = await stat24(path192);
+    const stats = await stat24(path202);
     if (!stats.isDirectory()) {
       return false;
     }
-    return hasFlintToml(path192);
+    return hasFlintToml(path202);
   } catch {
     return false;
   }
 }
-async function getFlintNameFromPath(path192) {
+async function getFlintNameFromPath(path202) {
   try {
-    const toml = await readFlintToml(path192);
+    const toml = await readFlintToml(path202);
     if (!toml) return null;
     return toml.flint?.name ?? null;
   } catch {
@@ -14431,9 +14433,9 @@ function normalizePlateName(name) {
 function isSlug(value) {
   return /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(value);
 }
-async function fileExists2(path192) {
+async function fileExists2(path202) {
   try {
-    await stat32(path192);
+    await stat32(path202);
     return true;
   } catch {
     return false;
@@ -16131,9 +16133,9 @@ async function createArtifactFromTemplate(flintPath, request) {
       throw new Error(`Unsupported template: ${request.template}`);
   }
 }
-async function pathExists4(path192) {
+async function pathExists4(path202) {
   try {
-    await stat42(path192);
+    await stat42(path202);
     return true;
   } catch {
     return false;
@@ -16388,9 +16390,9 @@ function getTinderboxFlintMode(declaration) {
 function getTinderboxFolderName(name) {
   return `(Flint) ${name}`;
 }
-async function pathExists32(path192) {
+async function pathExists32(path202) {
   try {
-    await stat52(path192);
+    await stat52(path202);
     return true;
   } catch {
     return false;
@@ -16681,10 +16683,10 @@ async function reconcileTinderbox(root, config) {
   });
   return { matched, undeclared, missing, renamed };
 }
-function buildFlintEntry(path192, name, toml) {
+function buildFlintEntry(path202, name, toml) {
   const entry = {
     name,
-    path: resolve32(path192),
+    path: resolve32(path202),
     source: "local"
   };
   if (toml?.flint.tags?.length) {
@@ -17093,15 +17095,15 @@ async function setTinderboxIdentity(root, name) {
   }
   return { applied, failed };
 }
-async function countFiles(path192) {
-  const stats = await stat52(path192);
+async function countFiles(path202) {
+  const stats = await stat52(path202);
   if (!stats.isDirectory()) {
     return 1;
   }
-  const entries = await readdir42(path192, { withFileTypes: true });
+  const entries = await readdir42(path202, { withFileTypes: true });
   let count = 1;
   for (const entry of entries) {
-    count += await countFiles(join92(path192, entry.name));
+    count += await countFiles(join92(path202, entry.name));
   }
   return count;
 }
@@ -19054,8 +19056,8 @@ async function isRebaseInProgress(cwd) {
   const result = await runGit(cwd, ["rev-parse", "--git-path", "rebase-merge"]);
   if (result.success) {
     const { access: access32 } = await import("fs/promises");
-    const path192 = await import("path");
-    const rebasePath = path192.resolve(cwd, result.output.trim());
+    const path202 = await import("path");
+    const rebasePath = path202.resolve(cwd, result.output.trim());
     try {
       await access32(rebasePath);
       return true;
@@ -19065,8 +19067,8 @@ async function isRebaseInProgress(cwd) {
   const result2 = await runGit(cwd, ["rev-parse", "--git-path", "rebase-apply"]);
   if (result2.success) {
     const { access: access32 } = await import("fs/promises");
-    const path192 = await import("path");
-    const rebasePath = path192.resolve(cwd, result2.output.trim());
+    const path202 = await import("path");
+    const rebasePath = path202.resolve(cwd, result2.output.trim());
     try {
       await access32(rebasePath);
       return true;
@@ -19080,8 +19082,8 @@ async function getRebaseBranch(cwd) {
   const result = await runGit(cwd, ["rev-parse", "--git-path", "rebase-merge/head-name"]);
   if (result.success) {
     const { readFile: readFile92 } = await import("fs/promises");
-    const path192 = await import("path");
-    const headNamePath = path192.resolve(cwd, result.output.trim());
+    const path202 = await import("path");
+    const headNamePath = path202.resolve(cwd, result.output.trim());
     try {
       const ref = (await readFile92(headNamePath, "utf-8")).trim();
       return ref.replace(/^refs\/heads\//, "");
@@ -19099,7 +19101,7 @@ async function getConflictFiles(cwd) {
 }
 async function hasConflictMarkers(cwd, files) {
   const { readFile: readFile92 } = await import("fs/promises");
-  const path192 = await import("path");
+  const path202 = await import("path");
   let filesToCheck = files;
   if (!filesToCheck || filesToCheck.length === 0) {
     const result = await runGit(cwd, ["diff", "--name-only", "HEAD"]);
@@ -19117,7 +19119,7 @@ async function hasConflictMarkers(cwd, files) {
   const conflicted = [];
   for (const file of filesToCheck) {
     try {
-      const content = await readFile92(path192.resolve(cwd, file), "utf-8");
+      const content = await readFile92(path202.resolve(cwd, file), "utf-8");
       if (content.includes("<<<<<<<") && content.includes("=======") && content.includes(">>>>>>>")) {
         conflicted.push(file);
       }
@@ -19413,6 +19415,13 @@ async function resolveSource(flintPath, ref) {
     return { status: "unfulfilled", name: ref, type: "flint-bundle", path: sourcePath };
   }
 }
+function resolvePromptsBasePath() {
+  try {
+    return resolvePackageBasePath("@nuucognition/flint", import.meta.url);
+  } catch {
+    return path22.resolve(path22.dirname(fileURLToPath22(import.meta.url)), "_flint");
+  }
+}
 async function loadFlintPrompt(name, variables = {}) {
   return loadPrompt(name, variables, {
     basePath: PROMPTS_BASE_PATH,
@@ -19430,9 +19439,9 @@ async function buildFlintApplicationPrompt(flintPath) {
   }
   return (await loadFlintPrompt("flint-application", { person })).trim();
 }
-async function exists22(path192) {
+async function exists22(path202) {
   try {
-    await stat92(path192);
+    await stat92(path202);
     return true;
   } catch {
     return false;
@@ -19866,13 +19875,13 @@ async function applyEffect(world, effect) {
       await writeFlintJsonPatch(world.root, effect.patch);
       return;
     case "writeSharedFile":
-      await writeFile9(path22.resolve(world.root, effect.path), effect.contents);
+      await writeFile9(path32.resolve(world.root, effect.path), effect.contents);
       return;
     case "deleteSharedPath":
-      await deletePath(path22.resolve(world.root, effect.path));
+      await deletePath(path32.resolve(world.root, effect.path));
       return;
     case "writeLocalFile":
-      await writeFile9(path22.resolve(world.root, ".flint", effect.path), effect.contents);
+      await writeFile9(path32.resolve(world.root, ".flint", effect.path), effect.contents);
       return;
   }
 }
@@ -19883,25 +19892,25 @@ async function writeFlintJsonPatch(root, patch) {
   await writeFlintJson2(root, merged);
 }
 async function writeFile9(file, contents) {
-  await fs22.mkdir(path22.dirname(file), { recursive: true });
+  await fs22.mkdir(path32.dirname(file), { recursive: true });
   await fs22.writeFile(file, contents, "utf8");
 }
 async function deletePath(target) {
   await fs22.rm(target, { recursive: true, force: true });
 }
 async function syncMarkers(root, set) {
-  const dir = path32.join(root, set.dir);
+  const dir = path42.join(root, set.dir);
   await fs32.mkdir(dir, { recursive: true });
   const expected = /* @__PURE__ */ new Set();
   for (const entry of set.entries) {
     expected.add(entry.filename);
-    const file = path32.join(dir, entry.filename);
+    const file = path42.join(dir, entry.filename);
     await fs32.writeFile(file, renderMarker(entry), "utf8");
   }
   const existing = await fs32.readdir(dir, { withFileTypes: true });
   for (const dirent of existing) {
     if (expected.has(dirent.name)) continue;
-    await fs32.rm(path32.join(dir, dirent.name), { recursive: true, force: true });
+    await fs32.rm(path42.join(dir, dirent.name), { recursive: true, force: true });
   }
 }
 function renderMarker(marker) {
@@ -20002,15 +20011,15 @@ async function runPhase(features2, world, opts, plan, receipts) {
   return dispatchDrifts(drifts, features2, world, opts, plan, receipts);
 }
 async function pruneMetadataParents(root, markerDirs) {
-  const METADATA_ROOT = path42.join("Mesh", "Metadata");
+  const METADATA_ROOT = path52.join("Mesh", "Metadata");
   const expectedByParent = /* @__PURE__ */ new Map();
   for (const dir of markerDirs) {
-    const norm = path42.normalize(dir);
-    if (!norm.startsWith(METADATA_ROOT + path42.sep) && norm !== METADATA_ROOT) continue;
+    const norm = path52.normalize(dir);
+    if (!norm.startsWith(METADATA_ROOT + path52.sep) && norm !== METADATA_ROOT) continue;
     let cur = norm;
-    while (cur !== METADATA_ROOT && cur !== "." && cur !== path42.dirname(cur)) {
-      const parent = path42.dirname(cur);
-      const child = path42.basename(cur);
+    while (cur !== METADATA_ROOT && cur !== "." && cur !== path52.dirname(cur)) {
+      const parent = path52.dirname(cur);
+      const child = path52.basename(cur);
       if (!expectedByParent.has(parent)) expectedByParent.set(parent, /* @__PURE__ */ new Set());
       expectedByParent.get(parent).add(child);
       if (parent === METADATA_ROOT) break;
@@ -20018,7 +20027,7 @@ async function pruneMetadataParents(root, markerDirs) {
     }
   }
   for (const [parent, expected] of expectedByParent) {
-    const parentAbs = path42.join(root, parent);
+    const parentAbs = path52.join(root, parent);
     let entries;
     try {
       entries = await fs42.readdir(parentAbs, { withFileTypes: true });
@@ -20027,7 +20036,7 @@ async function pruneMetadataParents(root, markerDirs) {
     }
     for (const dirent of entries) {
       if (expected.has(dirent.name)) continue;
-      await fs42.rm(path42.join(parentAbs, dirent.name), { recursive: true, force: true });
+      await fs42.rm(path52.join(parentAbs, dirent.name), { recursive: true, force: true });
     }
   }
 }
@@ -20061,7 +20070,7 @@ async function loadWorld(root, opts = {}) {
   const parseErrors = [];
   const intent = await readIntent(root, parseErrors);
   const entity = await readEntity(root, parseErrors);
-  const local = await walkLocal(path52.join(root, localDir), root, parseErrors);
+  const local = await walkLocal(path6.join(root, localDir), root, parseErrors);
   return { root, intent, entity, local, parseErrors };
 }
 async function readIntent(root, parseErrors) {
@@ -20131,7 +20140,7 @@ async function walkLocal(dir, root, parseErrors) {
     throw err;
   }
   for (const entry of entries) {
-    const full = path52.join(dir, entry.name);
+    const full = path6.join(dir, entry.name);
     if (entry.isDirectory()) {
       out[entry.name] = await walkLocal(full, root, parseErrors);
     } else {
@@ -20142,7 +20151,7 @@ async function walkLocal(dir, root, parseErrors) {
           JSON.parse(content);
         } catch (err) {
           parseErrors.push({
-            source: path52.relative(root, full),
+            source: path6.relative(root, full),
             path: full,
             message: err instanceof Error ? err.message : String(err)
           });
@@ -20214,7 +20223,7 @@ function partitionIntent(world) {
   });
 }
 function renderBody2(entry) {
-  const repoPath = path7.join(BUNDLE_EXPORTS_DIR, `(Bundle) ${entry.name}`);
+  const repoPath = path8.join(BUNDLE_EXPORTS_DIR, `(Bundle) ${entry.name}`);
   return [
     `# ${entry.name}`,
     "",
@@ -20355,7 +20364,7 @@ function toSnake6(name) {
   return name.trim().replace(/[^A-Za-z0-9]+/g, "_").replace(/^_+|_+$/g, "").toLowerCase();
 }
 function renderMarkerBody(entry) {
-  const repoPath = path12.join(WORKSPACE_REPOS_DIR, entry.name);
+  const repoPath = path13.join(WORKSPACE_REPOS_DIR, entry.name);
   return [
     `# ${entry.name}`,
     "",
@@ -20406,7 +20415,7 @@ async function readShardSpecAndErrors(folderPath) {
   return { shardSpec: snapshot?.["shard-spec"] ?? null, errors };
 }
 async function listDevLocalFolders(flintPath) {
-  const shardsDir = path13.join(flintPath, SHARDS_DIR);
+  const shardsDir = path14.join(flintPath, SHARDS_DIR);
   let entries;
   try {
     entries = await fs10.readdir(shardsDir, { withFileTypes: true });
@@ -20426,9 +20435,9 @@ async function listDevLocalFolders(flintPath) {
 }
 async function healScaffolding(folderPath, entry) {
   for (const sub of SHARD_SPEC_DIRS_SOURCE) {
-    await fs10.mkdir(path13.join(folderPath, sub), { recursive: true });
+    await fs10.mkdir(path14.join(folderPath, sub), { recursive: true });
   }
-  const yamlPath = path13.join(folderPath, "shard.yaml");
+  const yamlPath = path14.join(folderPath, "shard.yaml");
   if (!await fileExists22(yamlPath)) {
     const stub = `shard-spec: "0.2.0"
 version: "0.1.0"
@@ -20438,16 +20447,16 @@ description: ""
 `;
     await fs10.writeFile(yamlPath, stub, "utf-8");
   }
-  const readmePath = path13.join(folderPath, "README.md");
+  const readmePath = path14.join(folderPath, "README.md");
   if (!await fileExists22(readmePath)) {
     await fs10.writeFile(readmePath, `# ${entry.name}
 `, "utf-8");
   }
-  const releasePath = path13.join(folderPath, "RELEASE.md");
+  const releasePath = path14.join(folderPath, "RELEASE.md");
   if (!await fileExists22(releasePath)) {
     await fs10.writeFile(releasePath, "# 0.1.0\n\n- Initial shard scaffold\n", "utf-8");
   }
-  const migrationsPath = path13.join(folderPath, "MIGRATIONS.md");
+  const migrationsPath = path14.join(folderPath, "MIGRATIONS.md");
   if (!await fileExists22(migrationsPath)) {
     await fs10.writeFile(
       migrationsPath,
@@ -20490,7 +20499,7 @@ async function readShardSpecAndErrors2(folderPath) {
   return { shardSpec: snapshot?.["shard-spec"] ?? null, errors };
 }
 async function listDevPrefixedFolders(flintPath, prefix) {
-  const shardsDir = path14.join(flintPath, SHARDS_DIR2);
+  const shardsDir = path15.join(flintPath, SHARDS_DIR2);
   let entries;
   try {
     entries = await fs11.readdir(shardsDir, { withFileTypes: true });
@@ -20517,7 +20526,7 @@ async function cloneEntry(flintPath, entry) {
   }
 }
 async function findDevRemoteFolder(flintPath, kebabName) {
-  const shardsDir = path14.join(flintPath, SHARDS_DIR2);
+  const shardsDir = path15.join(flintPath, SHARDS_DIR2);
   let entries;
   try {
     entries = await fs11.readdir(shardsDir, { withFileTypes: true });
@@ -20531,7 +20540,7 @@ async function findDevRemoteFolder(flintPath, kebabName) {
     const display = entry.name.slice("(Dev Remote) ".length);
     const displayKebab = display.replace(/[^A-Za-z0-9]+/g, "-").replace(/^-+|-+$/g, "").toLowerCase();
     if (displayKebab === lowered) {
-      return path14.join(shardsDir, entry.name);
+      return path15.join(shardsDir, entry.name);
     }
   }
   return null;
@@ -20575,11 +20584,11 @@ async function uninstallInstalledShard(flintPath, name) {
 }
 async function readSourceState(source, flintRoot) {
   if (!source) return { sourcePath: null, sourceMissing: false, sourceVersion: null };
-  const isExternalLocal = source.startsWith("./") || source.startsWith("../") || path15.isAbsolute(source);
+  const isExternalLocal = source.startsWith("./") || source.startsWith("../") || path16.isAbsolute(source);
   if (!isExternalLocal) {
     return { sourcePath: null, sourceMissing: false, sourceVersion: null };
   }
-  const sourcePath = path15.isAbsolute(source) ? source : path15.resolve(flintRoot, source);
+  const sourcePath = path16.isAbsolute(source) ? source : path16.resolve(flintRoot, source);
   const exists32 = await directoryExists2(sourcePath);
   if (!exists32) {
     return { sourcePath, sourceMissing: true, sourceVersion: null };
@@ -20616,7 +20625,7 @@ function driftOf6(payload) {
   return { feature: INSTALLED_SHARDS_FEATURE_ID, kind: payload.kind, payload };
 }
 async function collectManifests(flintPath) {
-  const shardsDir = path16.join(flintPath, SHARDS_DIR4);
+  const shardsDir = path17.join(flintPath, SHARDS_DIR4);
   let entries;
   try {
     entries = await fs13.readdir(shardsDir, { withFileTypes: true });
@@ -20627,7 +20636,7 @@ async function collectManifests(flintPath) {
   for (const entry of entries) {
     if (!entry.isDirectory()) continue;
     if (entry.name.startsWith("(Shards)")) continue;
-    const folderPath = path16.join(shardsDir, entry.name);
+    const folderPath = path17.join(shardsDir, entry.name);
     const read = await readShardManifest(folderPath).catch(() => null);
     const manifest = read?.manifest ?? await readShardManifestSnapshot(folderPath).catch(() => null);
     if (!manifest) continue;
@@ -20651,7 +20660,7 @@ function driftOf7(payload) {
   return { feature: FLINT_BUNDLES_FEATURE_ID, kind: payload.kind, payload };
 }
 function renderBody7(args) {
-  const repoPath = path17.join(FLINT_BUNDLES_DIR, args.bundleName);
+  const repoPath = path18.join(FLINT_BUNDLES_DIR, args.bundleName);
   return [
     `# ${args.bundleName}`,
     "",
@@ -20674,8 +20683,8 @@ async function copyDir3(src, dst) {
   await fs14.mkdir(dst, { recursive: true });
   const entries = await fs14.readdir(src, { withFileTypes: true });
   for (const entry of entries) {
-    const s = path17.join(src, entry.name);
-    const d = path17.join(dst, entry.name);
+    const s = path18.join(src, entry.name);
+    const d = path18.join(dst, entry.name);
     if (entry.isDirectory()) await copyDir3(s, d);
     else if (entry.isFile()) await fs14.copyFile(s, d);
   }
@@ -20692,7 +20701,7 @@ function partitionIntent11(world) {
   });
 }
 function renderBody8(entry) {
-  const repoPath = path18.join(SOURCE_REPOS_DIR, entry.name);
+  const repoPath = path19.join(SOURCE_REPOS_DIR, entry.name);
   return [
     `# ${entry.name}`,
     "",
@@ -20832,7 +20841,7 @@ var init_dist4 = __esm({
     execAsync4 = promisify52(exec4);
     __dirname2 = dirname42(fileURLToPath2(import.meta.url));
     presetsCache = null;
-    PROMPTS_BASE_PATH = resolvePackageBasePath("@nuucognition/flint", import.meta.url);
+    PROMPTS_BASE_PATH = resolvePromptsBasePath();
     IntentFrameSchema = external_exports.object({
       flint: external_exports.object({
         name: external_exports.string(),
@@ -20856,7 +20865,7 @@ var init_dist4 = __esm({
     EMPTY_INTENT = { flint: { name: "" } };
     EMPTY_ENTITY = {};
     IDENTITY_FEATURE_ID = "identity";
-    IDENTITY_MARKERS_DIR = path6.join("Mesh", "Metadata", "Constitutive", "Identity");
+    IDENTITY_MARKERS_DIR = path7.join("Mesh", "Metadata", "Constitutive", "Identity");
     identity2 = {
       id: IDENTITY_FEATURE_ID,
       healStrategy: { unidentified: "auto", unnamed: "block" },
@@ -20929,7 +20938,7 @@ var init_dist4 = __esm({
     };
     BUNDLE_EXPORTS_FEATURE_ID = "bundle-exports";
     BUNDLE_EXPORTS_DIR = "Exports";
-    BUNDLE_EXPORTS_MARKERS_DIR = path7.join(
+    BUNDLE_EXPORTS_MARKERS_DIR = path8.join(
       "Mesh",
       "Metadata",
       "Outputs",
@@ -20951,12 +20960,12 @@ var init_dist4 = __esm({
         return { malformedDeclarations: partitionIntent(world).malformed };
       },
       async readActual(world) {
-        const dir = path7.join(world.root, BUNDLE_EXPORTS_DIR);
+        const dir = path8.join(world.root, BUNDLE_EXPORTS_DIR);
         try {
           const items = await fs72.readdir(dir, { withFileTypes: true });
           return items.filter((d) => d.isDirectory() && d.name.startsWith("(Bundle) ")).map((d) => ({
             name: d.name.slice("(Bundle) ".length),
-            path: path7.join(dir, d.name)
+            path: path8.join(dir, d.name)
           }));
         } catch (err) {
           if (err.code === "ENOENT") return [];
@@ -20975,7 +20984,7 @@ var init_dist4 = __esm({
               payload: {
                 kind: "missing",
                 entry,
-                targetPath: path7.join(BUNDLE_EXPORTS_DIR, `(Bundle) ${entry.name}`)
+                targetPath: path8.join(BUNDLE_EXPORTS_DIR, `(Bundle) ${entry.name}`)
               }
             });
           }
@@ -20988,7 +20997,7 @@ var init_dist4 = __esm({
               payload: {
                 kind: "extra",
                 bundleName: a.name,
-                targetPath: path7.join(BUNDLE_EXPORTS_DIR, `(Bundle) ${a.name}`)
+                targetPath: path8.join(BUNDLE_EXPORTS_DIR, `(Bundle) ${a.name}`)
               }
             });
           }
@@ -21030,7 +21039,7 @@ var init_dist4 = __esm({
       }
     };
     CODEBASE_REFERENCES_FEATURE_ID = "codebase-references";
-    CODEBASE_REFERENCES_MARKERS_DIR = path8.join(
+    CODEBASE_REFERENCES_MARKERS_DIR = path9.join(
       "Mesh",
       "Metadata",
       "References",
@@ -21100,7 +21109,7 @@ var init_dist4 = __esm({
       }
     };
     FLINT_BUNDLE_REFERENCES_FEATURE_ID = "flint-bundle-references";
-    FLINT_BUNDLE_REFERENCES_MARKERS_DIR = path9.join(
+    FLINT_BUNDLE_REFERENCES_MARKERS_DIR = path10.join(
       "Mesh",
       "Metadata",
       "References",
@@ -21172,7 +21181,7 @@ var init_dist4 = __esm({
             `Cannot fulfill flint bundle reference "${payload.entry.name}": producing flint "${flint}" not found in ~/.nuucognition/flint/registry.json. Run \`flint register\` inside that flint.`
           );
         }
-        const bundlePath = path9.join(producer.path, "Exports", `(Bundle) ${bundle}`);
+        const bundlePath = path10.join(producer.path, "Exports", `(Bundle) ${bundle}`);
         if (!await isDir(bundlePath)) {
           throw new Error(
             `Cannot fulfill flint bundle reference "${payload.entry.name}": producer flint "${flint}" has no export at ${bundlePath}. Run \`flint export bundle ${bundle}\` inside that flint.`
@@ -21200,7 +21209,7 @@ var init_dist4 = __esm({
       }
     };
     FLINT_REFERENCES_FEATURE_ID = "flint-references";
-    FLINT_REFERENCES_MARKERS_DIR = path10.join(
+    FLINT_REFERENCES_MARKERS_DIR = path11.join(
       "Mesh",
       "Metadata",
       "References",
@@ -21285,7 +21294,7 @@ var init_dist4 = __esm({
       }
     };
     LATTICE_REFERENCES_FEATURE_ID = "lattice-references";
-    LATTICE_REFERENCES_MARKERS_DIR = path11.join(
+    LATTICE_REFERENCES_MARKERS_DIR = path12.join(
       "Mesh",
       "Metadata",
       "References",
@@ -21356,8 +21365,8 @@ var init_dist4 = __esm({
     };
     execAsync5 = promisify62(exec5);
     WORKSPACE_REPOS_FEATURE_ID = "workspace-repos";
-    WORKSPACE_REPOS_DIR = path12.join("Workspace", "Repos");
-    WORKSPACE_REPOS_MARKERS_DIR = path12.join("Mesh", "Metadata", "Related", "Repos");
+    WORKSPACE_REPOS_DIR = path13.join("Workspace", "Repos");
+    WORKSPACE_REPOS_MARKERS_DIR = path13.join("Mesh", "Metadata", "Related", "Repos");
     WorkspaceRepoEntrySchema = external_exports.object({
       name: external_exports.string().min(1),
       url: external_exports.string().url()
@@ -21377,7 +21386,7 @@ var init_dist4 = __esm({
         return { malformedDeclarations: partitionIntent6(world).malformed };
       },
       async readActual(world) {
-        const dir = path12.join(world.root, WORKSPACE_REPOS_DIR);
+        const dir = path13.join(world.root, WORKSPACE_REPOS_DIR);
         let entries;
         try {
           const items = await fs9.readdir(dir, { withFileTypes: true });
@@ -21388,7 +21397,7 @@ var init_dist4 = __esm({
         }
         const repos = [];
         for (const name of entries) {
-          const repoPath = path12.join(dir, name);
+          const repoPath = path13.join(dir, name);
           const [originUrl, hasUncommittedChanges2] = await Promise.all([
             readOriginUrl(repoPath),
             readDirty(repoPath)
@@ -21408,7 +21417,7 @@ var init_dist4 = __esm({
               driftOf5({
                 kind: "missing",
                 entry,
-                targetPath: path12.join(WORKSPACE_REPOS_DIR, entry.name)
+                targetPath: path13.join(WORKSPACE_REPOS_DIR, entry.name)
               })
             );
             continue;
@@ -21430,7 +21439,7 @@ var init_dist4 = __esm({
               driftOf5({
                 kind: "extra",
                 name: cloned.name,
-                targetPath: path12.join(WORKSPACE_REPOS_DIR, cloned.name)
+                targetPath: path13.join(WORKSPACE_REPOS_DIR, cloned.name)
               })
             );
           }
@@ -21443,8 +21452,8 @@ var init_dist4 = __esm({
       async apply(drift, world) {
         const payload = drift.payload;
         if (payload.kind !== "missing") return [];
-        const target = path12.join(world.root, payload.targetPath);
-        await fs9.mkdir(path12.dirname(target), { recursive: true });
+        const target = path13.join(world.root, payload.targetPath);
+        await fs9.mkdir(path13.dirname(target), { recursive: true });
         await execAsync5(
           `git clone ${shellQuote(payload.entry.url)} ${shellQuote(target)}`
         );
@@ -21526,20 +21535,20 @@ var init_dist4 = __esm({
         const intent = partitionIntent7(world).valid;
         const declared = [];
         for (const entry of intent) {
-          const resolvedPath = path13.isAbsolute(entry.source) ? entry.source : path13.resolve(world.root, entry.source);
+          const resolvedPath = path14.isAbsolute(entry.source) ? entry.source : path14.resolve(world.root, entry.source);
           const exists32 = await directoryExists(resolvedPath);
-          const hasManifest = exists32 ? await fileExists22(path13.join(resolvedPath, "shard.yaml")) : false;
+          const hasManifest = exists32 ? await fileExists22(path14.join(resolvedPath, "shard.yaml")) : false;
           const { shardSpec, errors: manifestErrors } = hasManifest ? await readShardSpecAndErrors(resolvedPath) : { shardSpec: null, errors: [] };
           const missingDirs = [];
           const missingRootFiles = [];
           if (exists32) {
             for (const sub of SHARD_SPEC_DIRS_SOURCE) {
-              if (!await directoryExists(path13.join(resolvedPath, sub))) {
+              if (!await directoryExists(path14.join(resolvedPath, sub))) {
                 missingDirs.push(sub);
               }
             }
             for (const f of REQUIRED_ROOT_FILES) {
-              if (!await fileExists22(path13.join(resolvedPath, f))) {
+              if (!await fileExists22(path14.join(resolvedPath, f))) {
                 missingRootFiles.push(f);
               }
             }
@@ -21614,7 +21623,7 @@ var init_dist4 = __esm({
             payload: {
               kind: "orphan",
               name: folderName,
-              folderPath: path13.join(SHARDS_DIR, folderName)
+              folderPath: path14.join(SHARDS_DIR, folderName)
             }
           });
         }
@@ -21654,7 +21663,7 @@ var init_dist4 = __esm({
             declared.push({ name: entry.name, folderPath: null, hasManifest: false, shardSpec: null, manifestErrors: [] });
             continue;
           }
-          const hasManifest = await fileExists3(path14.join(folderPath, "shard.yaml"));
+          const hasManifest = await fileExists3(path15.join(folderPath, "shard.yaml"));
           const { shardSpec, errors: manifestErrors } = hasManifest ? await readShardSpecAndErrors2(folderPath) : { shardSpec: null, errors: [] };
           declared.push({ name: entry.name, folderPath, hasManifest, shardSpec, manifestErrors });
         }
@@ -21716,7 +21725,7 @@ var init_dist4 = __esm({
             payload: {
               kind: "orphan",
               name: folderName,
-              folderPath: path14.join(SHARDS_DIR2, folderName)
+              folderPath: path15.join(SHARDS_DIR2, folderName)
             }
           });
         }
@@ -21754,13 +21763,13 @@ var init_dist4 = __esm({
         const intent = partitionIntent9(world).valid;
         const onDiskNames = [];
         const byKebab = /* @__PURE__ */ new Map();
-        const shardsDir = path15.join(world.root, SHARDS_DIR3);
+        const shardsDir = path16.join(world.root, SHARDS_DIR3);
         try {
           const entries = await fs12.readdir(shardsDir, { withFileTypes: true });
           for (const entry of entries) {
             if (!entry.isDirectory()) continue;
             if (!isInstalledShapedFolder(entry.name)) continue;
-            const yaml = path15.join(shardsDir, entry.name, "shard.yaml");
+            const yaml = path16.join(shardsDir, entry.name, "shard.yaml");
             if (!await fileExists4(yaml)) continue;
             onDiskNames.push(entry.name);
             byKebab.set(folderToKebab(entry.name), entry.name);
@@ -21777,7 +21786,7 @@ var init_dist4 = __esm({
           if (!folderName) {
             installed.push({
               name: entry.name,
-              folderPath: path15.join(shardsDir, entry.name),
+              folderPath: path16.join(shardsDir, entry.name),
               manifestVersion: null,
               recordedVersion: null,
               manifestErrors: [],
@@ -21787,7 +21796,7 @@ var init_dist4 = __esm({
             });
             continue;
           }
-          const folderPath = path15.join(shardsDir, folderName);
+          const folderPath = path16.join(shardsDir, folderName);
           const manifestRead = await readShardManifest(folderPath).catch(() => null);
           const manifestSnap = manifestRead?.manifest ?? await readShardManifestSnapshot(folderPath).catch(() => null);
           const manifestVersion = manifestSnap?.version ?? null;
@@ -21823,7 +21832,7 @@ var init_dist4 = __esm({
               driftOf6({
                 kind: "not-installed",
                 entry,
-                targetPath: path15.join(SHARDS_DIR3, entry.name)
+                targetPath: path16.join(SHARDS_DIR3, entry.name)
               })
             );
             continue;
@@ -21868,7 +21877,7 @@ var init_dist4 = __esm({
             driftOf6({
               kind: "orphan",
               name: folderName,
-              folderPath: path15.join(SHARDS_DIR3, folderName)
+              folderPath: path16.join(SHARDS_DIR3, folderName)
             })
           );
         }
@@ -21922,8 +21931,8 @@ var init_dist4 = __esm({
       }
     };
     FLINT_BUNDLES_FEATURE_ID = "flint-bundles";
-    FLINT_BUNDLES_DIR = path17.join("Sources", "Bundles");
-    FLINT_BUNDLES_MARKERS_DIR = path17.join(
+    FLINT_BUNDLES_DIR = path18.join("Sources", "Bundles");
+    FLINT_BUNDLES_MARKERS_DIR = path18.join(
       "Mesh",
       "Metadata",
       "Sources",
@@ -21950,10 +21959,10 @@ var init_dist4 = __esm({
         return { malformedDeclarations: partitionIntent10(world).malformed };
       },
       async readActual(world) {
-        const dir = path17.join(world.root, FLINT_BUNDLES_DIR);
+        const dir = path18.join(world.root, FLINT_BUNDLES_DIR);
         try {
           const items = await fs14.readdir(dir, { withFileTypes: true });
-          return items.filter((d) => d.isDirectory()).map((d) => ({ name: d.name, path: path17.join(dir, d.name) }));
+          return items.filter((d) => d.isDirectory()).map((d) => ({ name: d.name, path: path18.join(dir, d.name) }));
         } catch (err) {
           if (err.code === "ENOENT") return [];
           throw err;
@@ -21970,7 +21979,7 @@ var init_dist4 = __esm({
               driftOf7({
                 kind: "missing",
                 entry,
-                targetPath: path17.join(FLINT_BUNDLES_DIR, bundle)
+                targetPath: path18.join(FLINT_BUNDLES_DIR, bundle)
               })
             );
           }
@@ -21981,7 +21990,7 @@ var init_dist4 = __esm({
               driftOf7({
                 kind: "extra",
                 bundleName: a.name,
-                targetPath: path17.join(FLINT_BUNDLES_DIR, a.name)
+                targetPath: path18.join(FLINT_BUNDLES_DIR, a.name)
               })
             );
           }
@@ -21998,15 +22007,15 @@ var init_dist4 = __esm({
             `Cannot import bundle "${payload.entry.name}": producing flint "${flint}" not found in ~/.nuucognition/flint/registry.json. Run \`flint register\` inside that flint.`
           );
         }
-        const sourceDir = path17.join(producer.path, "Exports", `(Bundle) ${bundle}`);
+        const sourceDir = path18.join(producer.path, "Exports", `(Bundle) ${bundle}`);
         if (!await isDir2(sourceDir)) {
           throw new Error(
             `Cannot import bundle "${payload.entry.name}": producer flint "${flint}" has no export at ${sourceDir}. Run \`flint export bundle ${bundle}\` inside that flint.`
           );
         }
-        const targetDir = path17.join(world.root, payload.targetPath);
+        const targetDir = path18.join(world.root, payload.targetPath);
         await fs14.rm(targetDir, { recursive: true, force: true });
-        await fs14.mkdir(path17.dirname(targetDir), { recursive: true });
+        await fs14.mkdir(path18.dirname(targetDir), { recursive: true });
         await copyDir3(sourceDir, targetDir);
         return [];
       },
@@ -22026,8 +22035,8 @@ var init_dist4 = __esm({
     };
     execAsync6 = promisify72(exec6);
     SOURCE_REPOS_FEATURE_ID = "source-repos";
-    SOURCE_REPOS_DIR = path18.join("Sources", "Repos");
-    SOURCE_REPOS_MARKERS_DIR = path18.join("Mesh", "Metadata", "Sources", "Repos");
+    SOURCE_REPOS_DIR = path19.join("Sources", "Repos");
+    SOURCE_REPOS_MARKERS_DIR = path19.join("Mesh", "Metadata", "Sources", "Repos");
     SourceRepoEntrySchema = external_exports.object({
       name: external_exports.string().min(1),
       url: external_exports.string().url()
@@ -22042,10 +22051,10 @@ var init_dist4 = __esm({
         return { malformedDeclarations: partitionIntent11(world).malformed };
       },
       async readActual(world) {
-        const dir = path18.join(world.root, SOURCE_REPOS_DIR);
+        const dir = path19.join(world.root, SOURCE_REPOS_DIR);
         try {
           const items = await fs15.readdir(dir, { withFileTypes: true });
-          return items.filter((d) => d.isDirectory()).map((d) => ({ name: d.name, path: path18.join(dir, d.name) }));
+          return items.filter((d) => d.isDirectory()).map((d) => ({ name: d.name, path: path19.join(dir, d.name) }));
         } catch (err) {
           if (err.code === "ENOENT") return [];
           throw err;
@@ -22063,7 +22072,7 @@ var init_dist4 = __esm({
               payload: {
                 kind: "missing",
                 entry,
-                targetPath: path18.join(SOURCE_REPOS_DIR, entry.name)
+                targetPath: path19.join(SOURCE_REPOS_DIR, entry.name)
               }
             });
           }
@@ -22076,7 +22085,7 @@ var init_dist4 = __esm({
               payload: {
                 kind: "extra",
                 name: repo.name,
-                targetPath: path18.join(SOURCE_REPOS_DIR, repo.name)
+                targetPath: path19.join(SOURCE_REPOS_DIR, repo.name)
               }
             });
           }
@@ -22086,12 +22095,12 @@ var init_dist4 = __esm({
       async apply(drift, world) {
         const payload = drift.payload;
         if (payload.kind !== "missing") return [];
-        const target = path18.join(world.root, payload.targetPath);
-        await fs15.mkdir(path18.dirname(target), { recursive: true });
+        const target = path19.join(world.root, payload.targetPath);
+        await fs15.mkdir(path19.dirname(target), { recursive: true });
         await execAsync6(
           `git clone --depth 1 ${shellQuote2(payload.entry.url)} ${shellQuote2(target)}`
         );
-        await fs15.rm(path18.join(target, ".git"), { recursive: true, force: true });
+        await fs15.rm(path19.join(target, ".git"), { recursive: true, force: true });
         return [];
       },
       markers(intent) {
@@ -69672,15 +69681,15 @@ var require_route2 = __commonJS({
       };
     }
     function wrapConversion(toModel, graph) {
-      const path29 = [graph[toModel].parent, toModel];
+      const path30 = [graph[toModel].parent, toModel];
       let fn = conversions[graph[toModel].parent][toModel];
       let cur = graph[toModel].parent;
       while (graph[cur].parent) {
-        path29.unshift(graph[cur].parent);
+        path30.unshift(graph[cur].parent);
         fn = link5(conversions[graph[cur].parent][cur], fn);
         cur = graph[cur].parent;
       }
-      fn.conversion = path29;
+      fn.conversion = path30;
       return fn;
     }
     module.exports = function(fromModel) {
@@ -83379,7 +83388,7 @@ var require_brace_expansion = __commonJS({
 
 // src/index.ts
 import { readFileSync as readFileSync18 } from "fs";
-import { fileURLToPath as fileURLToPath7 } from "url";
+import { fileURLToPath as fileURLToPath8 } from "url";
 import { dirname as dirname13, join as join49 } from "path";
 
 // ../../../main/packages/cli-core/dist/index.js
@@ -84463,7 +84472,7 @@ var require_command = __commonJS2({
     "use strict";
     var EventEmitter3 = __require2("events").EventEmitter;
     var childProcess2 = __require2("child_process");
-    var path29 = __require2("path");
+    var path210 = __require2("path");
     var fs62 = __require2("fs");
     var process112 = __require2("process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
@@ -85396,9 +85405,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let launchWithNode = false;
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
-          const localBin = path29.resolve(baseDir, baseName);
+          const localBin = path210.resolve(baseDir, baseName);
           if (fs62.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path29.extname(baseName))) return void 0;
+          if (sourceExt.includes(path210.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
             (ext2) => fs62.existsSync(`${localBin}${ext2}`)
           );
@@ -85416,17 +85425,17 @@ Expecting one of '${allowedValues.join("', '")}'`);
           } catch (err) {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path29.resolve(
-            path29.dirname(resolvedScriptPath),
+          executableDir = path210.resolve(
+            path210.dirname(resolvedScriptPath),
             executableDir
           );
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path29.basename(
+            const legacyName = path210.basename(
               this._scriptPath,
-              path29.extname(this._scriptPath)
+              path210.extname(this._scriptPath)
             );
             if (legacyName !== this._name) {
               localFile = findFile(
@@ -85437,7 +85446,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path29.extname(executableFile));
+        launchWithNode = sourceExt.includes(path210.extname(executableFile));
         let proc;
         if (process112.platform !== "win32") {
           if (launchWithNode) {
@@ -86277,7 +86286,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @return {Command}
        */
       nameFromFilename(filename) {
-        this._name = path29.basename(filename, path29.extname(filename));
+        this._name = path210.basename(filename, path210.extname(filename));
         return this;
       }
       /**
@@ -129343,15 +129352,15 @@ var require_route = __commonJS2({
       };
     }
     function wrapConversion(toModel, graph) {
-      const path29 = [graph[toModel].parent, toModel];
+      const path210 = [graph[toModel].parent, toModel];
       let fn = conversions[graph[toModel].parent][toModel];
       let cur = graph[toModel].parent;
       while (graph[cur].parent) {
-        path29.unshift(graph[cur].parent);
+        path210.unshift(graph[cur].parent);
         fn = link32(conversions[graph[cur].parent][cur], fn);
         cur = graph[cur].parent;
       }
-      fn.conversion = path29;
+      fn.conversion = path210;
       return fn;
     }
     module.exports = function(fromModel) {
@@ -150191,10 +150200,10 @@ async function loadAuth(env22 = "prod") {
 }
 function loadAuthSync(env22 = "prod") {
   ensureNuuDirSync();
-  const path29 = authPath(env22);
-  if (!existsSync(path29)) return null;
+  const path210 = authPath(env22);
+  if (!existsSync(path210)) return null;
   try {
-    return normalizeCredentials(JSON.parse(readFileSync(path29, "utf-8")));
+    return normalizeCredentials(JSON.parse(readFileSync(path210, "utf-8")));
   } catch (error22) {
     if (error22.code === "ENOENT") {
       return null;
@@ -151284,9 +151293,9 @@ function stringify(obj, { maxDepth = 1e3, numbersAsFloat = false } = {}) {
     return str + "\n";
   return str;
 }
-async function readConfigFile(path29) {
+async function readConfigFile(path210) {
   try {
-    const content = await fsReadFile(path29, "utf-8");
+    const content = await fsReadFile(path210, "utf-8");
     return parse(content);
   } catch (error22) {
     if (error22.code === "ENOENT") {
@@ -151295,9 +151304,9 @@ async function readConfigFile(path29) {
     throw error22;
   }
 }
-function readConfigFileSync(path29) {
+function readConfigFileSync(path210) {
   try {
-    const content = fsReadFileSync(path29, "utf-8");
+    const content = fsReadFileSync(path210, "utf-8");
     return parse(content);
   } catch (error22) {
     if (error22.code === "ENOENT") {
@@ -151306,15 +151315,15 @@ function readConfigFileSync(path29) {
     throw error22;
   }
 }
-async function writeConfigFile(path29, data) {
-  await mkdir3(dirname2(path29), { recursive: true });
-  await fsWriteFile(path29, `${stringify(data)}
+async function writeConfigFile(path210, data) {
+  await mkdir3(dirname2(path210), { recursive: true });
+  await fsWriteFile(path210, `${stringify(data)}
 `, "utf-8");
 }
-async function setConfigField(path29, key, value) {
-  const existing = await readConfigFile(path29) ?? {};
+async function setConfigField(path210, key, value) {
+  const existing = await readConfigFile(path210) ?? {};
   existing[key] = value;
-  await writeConfigFile(path29, existing);
+  await writeConfigFile(path210, existing);
 }
 var CONFIG_FILENAME = "config.toml";
 function getConfigDir(cliname, profile2) {
@@ -155730,9 +155739,9 @@ function compareVersions(left, right) {
 function sortMigrations(migrations3) {
   return [...migrations3].sort((left, right) => compareVersions(left.version, right.version));
 }
-async function readMigrationState(path29) {
+async function readMigrationState(path210) {
   try {
-    const content = await readFile3(path29, "utf-8");
+    const content = await readFile3(path210, "utf-8");
     return JSON.parse(content);
   } catch (error22) {
     if (error22.code === "ENOENT") {
@@ -155741,9 +155750,9 @@ async function readMigrationState(path29) {
     throw error22;
   }
 }
-async function writeMigrationState(path29, state) {
-  await mkdir4(dirname3(path29), { recursive: true });
-  await writeFile3(path29, `${JSON.stringify(state, null, 2)}
+async function writeMigrationState(path210, state) {
+  await mkdir4(dirname3(path210), { recursive: true });
+  await writeFile3(path210, `${JSON.stringify(state, null, 2)}
 `, "utf-8");
 }
 async function backupAppDir(cliname, appDir, currentVersion, nextVersion) {
@@ -156134,25 +156143,25 @@ import { promisify as promisify9 } from "util";
 import { homedir as homedir4 } from "os";
 import { access as access6 } from "fs/promises";
 import { createInterface } from "readline";
-function abbreviatePath(path29) {
+function abbreviatePath(path30) {
   const home = homedir4();
-  if (path29.startsWith(home)) {
-    return path29.replace(home, "~");
+  if (path30.startsWith(home)) {
+    return path30.replace(home, "~");
   }
-  return path29;
+  return path30;
 }
-function expandPath(path29) {
-  if (path29.startsWith("~/")) {
-    return path29.replace("~", homedir4());
+function expandPath(path30) {
+  if (path30.startsWith("~/")) {
+    return path30.replace("~", homedir4());
   }
-  return path29;
+  return path30;
 }
 function padEnd(str, length) {
   return str.padEnd(length);
 }
-async function checkPathExists(path29) {
+async function checkPathExists(path30) {
   try {
-    await access6(path29);
+    await access6(path30);
     return true;
   } catch {
     return false;
@@ -156476,12 +156485,12 @@ function resolvePath2(flint, fullPath) {
 }
 function printFlint(flint, opts) {
   const { nameColWidth, showStatus, fullPath, indent = "  " } = opts;
-  const path29 = resolvePath2(flint, fullPath);
+  const path30 = resolvePath2(flint, fullPath);
   const isBroken = showStatus && !flint.valid;
   const tags = formatTags(flint.tags);
   const nameCell = tags ? `${export_pc.bold(flint.name)}  ${tags}` : export_pc.bold(flint.name);
   const status = showStatus ? statusBadge(flint) + " " : "";
-  const pathColor = isBroken ? export_pc.red(path29) : export_pc.dim(path29);
+  const pathColor = isBroken ? export_pc.red(path30) : export_pc.dim(path30);
   console.log(`${indent}${pad(nameCell, nameColWidth)}${status}${pathColor}`);
   if (flint.description) {
     console.log(`${indent}  ${export_pc.dim(truncate2(flint.description, 65))}`);
@@ -156489,10 +156498,10 @@ function printFlint(flint, opts) {
 }
 function printGroupRow(flint, opts) {
   const { nameColWidth, showStatus, fullPath } = opts;
-  const path29 = resolvePath2(flint, fullPath);
+  const path30 = resolvePath2(flint, fullPath);
   const isBroken = showStatus && !flint.valid;
   const status = showStatus ? statusBadge(flint) + " " : "";
-  const pathColor = isBroken ? export_pc.red(path29) : export_pc.dim(path29);
+  const pathColor = isBroken ? export_pc.red(path30) : export_pc.dim(path30);
   console.log(`    ${pad(flint.name, nameColWidth)}${status}${pathColor}`);
 }
 function measureNameCol(flints) {
@@ -156748,17 +156757,17 @@ import { promisify as promisify10 } from "util";
 import { resolve as resolve9 } from "path";
 import { platform as platform5 } from "os";
 var execAsync8 = promisify10(exec8);
-async function openInObsidian(path29) {
+async function openInObsidian(path30) {
   const os7 = platform5();
   if (os7 === "darwin") {
-    await execAsync8(`open -a "Obsidian" "${path29}"`);
+    await execAsync8(`open -a "Obsidian" "${path30}"`);
   } else if (os7 === "win32") {
-    await execAsync8(`start "" "${path29}"`);
+    await execAsync8(`start "" "${path30}"`);
   } else {
     try {
-      await execAsync8(`obsidian "${path29}"`);
+      await execAsync8(`obsidian "${path30}"`);
     } catch {
-      await execAsync8(`xdg-open "${path29}"`);
+      await execAsync8(`xdg-open "${path30}"`);
     }
   }
 }
@@ -158187,11 +158196,11 @@ var resolveCommand = new Command("resolve").description("Resolve a reference to
 // src/commands/references/lattice.ts
 init_dist4();
 import fs16 from "fs";
-import path19 from "path";
+import path20 from "path";
 import crypto2 from "crypto";
 import { spawn as spawn4 } from "child_process";
 function getRegistryPath() {
-  return path19.join(getConfigDir("lattice"), "registry.json");
+  return path20.join(getConfigDir("lattice"), "registry.json");
 }
 function readRegistry() {
   const registryPath = getRegistryPath();
@@ -158205,7 +158214,7 @@ function resolveLattice(name) {
   return entry;
 }
 function readPinsToml(latticeRoot) {
-  const pinsPath = path19.join(latticeRoot, "pins.toml");
+  const pinsPath = path20.join(latticeRoot, "pins.toml");
   if (!fs16.existsSync(pinsPath)) return [];
   const content = fs16.readFileSync(pinsPath, "utf-8");
   const records = [];
@@ -158220,7 +158229,7 @@ function readPinsToml(latticeRoot) {
   return records;
 }
 function addToPinsToml(latticeRoot, id, title) {
-  const pinsPath = path19.join(latticeRoot, "pins.toml");
+  const pinsPath = path20.join(latticeRoot, "pins.toml");
   const existing = readPinsToml(latticeRoot);
   if (existing.some((p) => p.id === id)) return false;
   existing.push({ id, title });
@@ -158233,7 +158242,7 @@ ${records}
   return true;
 }
 function removeFromPinsToml(latticeRoot, id) {
-  const pinsPath = path19.join(latticeRoot, "pins.toml");
+  const pinsPath = path20.join(latticeRoot, "pins.toml");
   const existing = readPinsToml(latticeRoot);
   const pin = existing.find((p) => p.id === id);
   if (!pin) return null;
@@ -158253,10 +158262,10 @@ ${records}
   return pin;
 }
 function generateBaseContextFile(flintRoot, latticeName, lang, sourcePath) {
-  const latticeDir = path19.join(flintRoot, "Mesh", "Lattice", latticeName);
-  const pinsDir = path19.join(latticeDir, "Pins");
+  const latticeDir = path20.join(flintRoot, "Mesh", "Lattice", latticeName);
+  const pinsDir = path20.join(latticeDir, "Pins");
   fs16.mkdirSync(pinsDir, { recursive: true });
-  const contextPath = path19.join(latticeDir, `(Lattice) ${latticeName}.md`);
+  const contextPath = path20.join(latticeDir, `(Lattice) ${latticeName}.md`);
   if (fs16.existsSync(contextPath)) return;
   const id = crypto2.randomUUID();
   const content = `---
@@ -158312,27 +158321,27 @@ flint lattice run ${latticeName} get ${recordId}
 `;
 }
 function materializePin(flintRoot, latticeName, recordId, title) {
-  const pinsDir = path19.join(flintRoot, "Mesh", "Lattice", latticeName, "Pins");
+  const pinsDir = path20.join(flintRoot, "Mesh", "Lattice", latticeName, "Pins");
   fs16.mkdirSync(pinsDir, { recursive: true });
   const pinFileName = `(Lattice) ${latticeName} . ${title}.md`;
-  const pinFilePath = path19.join(pinsDir, pinFileName);
+  const pinFilePath = path20.join(pinsDir, pinFileName);
   if (fs16.existsSync(pinFilePath)) return false;
   fs16.writeFileSync(pinFilePath, generatePinFileContent(latticeName, recordId, title), "utf-8");
   updateBaseContextPins(flintRoot, latticeName, "add", title);
   return true;
 }
 function dematerializePin(flintRoot, latticeName, title) {
-  const pinsDir = path19.join(flintRoot, "Mesh", "Lattice", latticeName, "Pins");
+  const pinsDir = path20.join(flintRoot, "Mesh", "Lattice", latticeName, "Pins");
   const pinFileName = `(Lattice) ${latticeName} . ${title}.md`;
-  const pinFilePath = path19.join(pinsDir, pinFileName);
+  const pinFilePath = path20.join(pinsDir, pinFileName);
   if (!fs16.existsSync(pinFilePath)) return false;
   fs16.unlinkSync(pinFilePath);
   updateBaseContextPins(flintRoot, latticeName, "remove", title);
   return true;
 }
 function updateBaseContextPins(flintRoot, latticeName, action, title) {
-  const contextDir = path19.join(flintRoot, "Mesh", "Lattice", latticeName);
-  const contextPath = path19.join(contextDir, `(Lattice) ${latticeName}.md`);
+  const contextDir = path20.join(flintRoot, "Mesh", "Lattice", latticeName);
+  const contextPath = path20.join(contextDir, `(Lattice) ${latticeName}.md`);
   if (!fs16.existsSync(contextPath)) return;
   const content = fs16.readFileSync(contextPath, "utf-8");
   const wikilink = `- [[(Lattice) ${latticeName} . ${title}]]`;
@@ -158403,7 +158412,7 @@ var latticeCommand = new Command("lattice").description("Manage lattice connecti
     }
     const entry = { path: fulfillment.path, lang: fulfillment.lang, registered: fulfillment.fulfilled };
     const envLocal = {};
-    const envPath = path19.join(entry.path, ".env.local");
+    const envPath = path20.join(entry.path, ".env.local");
     if (fs16.existsSync(envPath)) {
       for (const line of fs16.readFileSync(envPath, "utf-8").split("\n")) {
         const trimmed = line.trim();
@@ -158418,7 +158427,7 @@ var latticeCommand = new Command("lattice").description("Manage lattice connecti
       }
     }
     const entryFile = entry.lang === "python" ? "main.py" : "main.js";
-    const entryPoint = path19.join(entry.path, entryFile);
+    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, {
@@ -158521,7 +158530,7 @@ var latticeCommand = new Command("lattice").description("Manage lattice connecti
       process.exit(1);
     }
     const pins = readPinsToml(fulfillment.path);
-    const pinsDir = path19.join(flintPath, "Mesh", "Lattice", name, "Pins");
+    const pinsDir = path20.join(flintPath, "Mesh", "Lattice", name, "Pins");
     let added = 0;
     let removed = 0;
     for (const pin of pins) {
@@ -158533,7 +158542,7 @@ var latticeCommand = new Command("lattice").description("Manage lattice connecti
       const declaredFiles = new Set(pins.map((p) => `(Lattice) ${name} . ${p.title}.md`));
       for (const file of fs16.readdirSync(pinsDir)) {
         if (file.endsWith(".md") && !declaredFiles.has(file)) {
-          fs16.unlinkSync(path19.join(pinsDir, file));
+          fs16.unlinkSync(path20.join(pinsDir, file));
           removed++;
         }
       }
@@ -158552,9 +158561,9 @@ init_dist4();
 import { readFile as readFile13, stat as stat15 } from "fs/promises";
 import { join as join27, basename as basename7 } from "path";
 import { createInterface as createInterface5 } from "readline";
-async function exists3(path29) {
+async function exists3(path30) {
   try {
-    await stat15(path29);
+    await stat15(path30);
     return true;
   } catch {
     return false;
@@ -158835,9 +158844,9 @@ init_dist4();
 import { randomUUID as randomUUID6 } from "crypto";
 import { copyFile as copyFile4, mkdir as mkdir15, writeFile as writeFile11, unlink as unlink3, stat as stat16 } from "fs/promises";
 import { join as join28, basename as basename8, resolve as resolve16 } from "path";
-async function exists4(path29) {
+async function exists4(path30) {
   try {
-    await stat16(path29);
+    await stat16(path30);
     return true;
   } catch {
     return false;
@@ -161730,7 +161739,7 @@ import { createInterface as createInterface7 } from "readline";
 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 join36, resolve as resolvePath3 } from "path";
-import { fileURLToPath as fileURLToPath5, pathToFileURL } from "url";
+import { fileURLToPath as fileURLToPath6, pathToFileURL } from "url";
 
 // ../../packages/orbh/dist/index.js
 import { existsSync as existsSync22, readFileSync as readFileSync22 } from "fs";
@@ -161775,7 +161784,8 @@ import { randomUUID as randomUUID33 } from "crypto";
 init_dist3();
 import { watch as watch3 } from "fs";
 import { access as access7 } from "fs/promises";
-import path20 from "path";
+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";
@@ -163066,8 +163076,8 @@ function diffEntries(previous, next) {
     newEntries: next.slice(index)
   };
 }
-function loadJsonFile(path29) {
-  return JSON.parse(readFileSync32(path29, "utf-8"));
+function loadJsonFile(path210) {
+  return JSON.parse(readFileSync32(path210, "utf-8"));
 }
 function isSessionInfo(value) {
   return isRecord6(value) && typeof value.id === "string";
@@ -164804,8 +164814,8 @@ function diffEntries2(previous, next) {
   }
   return previous.length === next.length && index === next.length ? [] : next.slice(index);
 }
-function isStreamCapturePath(path29) {
-  return path29.endsWith(".jsonl");
+function isStreamCapturePath(path210) {
+  return path210.endsWith(".jsonl");
 }
 function createOpencodeSessionWatcher(transcriptPath, options3) {
   return new OpencodeSessionWatcher(transcriptPath, options3);
@@ -164948,11 +164958,11 @@ var init_opencode_session_watcher = __esm2({
     };
   }
 });
-function normalizePath(path29) {
+function normalizePath(path210) {
   try {
-    return realpathSync(path29);
+    return realpathSync(path210);
   } catch {
-    return path29;
+    return path210;
   }
 }
 function parseStartedAtMs3(startedAt) {
@@ -166428,7 +166438,14 @@ function createOrbhWatcher(sessionsDir, options3 = {}) {
     }
   };
 }
-var PROMPTS_BASE_PATH2 = resolvePackageBasePath("@nuucognition/orbh", import.meta.url);
+function resolvePromptsBasePath2() {
+  try {
+    return resolvePackageBasePath("@nuucognition/orbh", import.meta.url);
+  } catch {
+    return path21.resolve(path21.dirname(fileURLToPath5(import.meta.url)), "_orbh");
+  }
+}
+var PROMPTS_BASE_PATH2 = resolvePromptsBasePath2();
 var DEFAULT_ORBH_COMMAND_PATH = "orbh";
 function normalizePromptLayer(value) {
   return value.trim();
@@ -166440,7 +166457,7 @@ async function loadOrbhPrompt(name, variables = {}) {
   });
 }
 async function tryLoadHarnessPrompt(runtime2, variables) {
-  const harnessPath = path20.join(PROMPTS_BASE_PATH2, "prompts", "harness", `${runtime2}.md`);
+  const harnessPath = path21.join(PROMPTS_BASE_PATH2, "prompts", "harness", `${runtime2}.md`);
   try {
     await access7(harnessPath);
   } catch {
@@ -167555,14 +167572,14 @@ init_registry();
 // ../../packages/orbh-server/dist/index.js
 init_dist();
 import { access as access8, readFile as readFile15 } from "fs/promises";
-import path21 from "path";
+import path23 from "path";
 import { homedir as homedir9 } from "os";
 import { randomUUID as randomUUID8 } from "crypto";
 import { spawn as spawn7 } from "child_process";
 import { readFile as readFile26 } from "fs/promises";
 import Fastify from "fastify";
 import { readFile as readFile36, writeFile as writeFile12, mkdir as mkdir16, rm as rm13 } from "fs/promises";
-import path23 from "path";
+import path24 from "path";
 var DEFAULT_HOST = "127.0.0.1";
 var DEFAULT_PORT = 13041;
 var DEFAULT_SESSIONS_DIR = ".orbh/sessions";
@@ -167575,7 +167592,7 @@ function expandHome(value) {
     return homedir9();
   }
   if (value.startsWith("~/")) {
-    return path21.join(homedir9(), value.slice(2));
+    return path23.join(homedir9(), value.slice(2));
   }
   return value;
 }
@@ -167622,10 +167639,10 @@ async function maybeReadConfig(configPath) {
   return parsed;
 }
 async function loadOrbhConfig(options3 = {}) {
-  const cwd = path21.resolve(options3.cwd ?? process.cwd());
-  const configPath = options3.configPath ? path21.resolve(cwd, options3.configPath) : path21.join(cwd, DEFAULT_CONFIG_FILENAME);
+  const cwd = path23.resolve(options3.cwd ?? process.cwd());
+  const configPath = options3.configPath ? path23.resolve(cwd, options3.configPath) : path23.join(cwd, DEFAULT_CONFIG_FILENAME);
   const parsed = await maybeReadConfig(configPath);
-  const configDir = path21.dirname(configPath);
+  const configDir = path23.dirname(configPath);
   const fileHost = normalizeHost(parsed?.server?.host);
   const filePort = normalizePort(parsed?.server?.port);
   const fileSessionsDir = normalizeSessionsDir(parsed?.sessions?.dir);
@@ -167636,7 +167653,7 @@ async function loadOrbhConfig(options3 = {}) {
   const overrideRuntimes = normalizeRuntimeOverrides(options3.overrides?.runtimes);
   const host = overrideHost ?? fileHost ?? DEFAULT_HOST;
   const port = overridePort ?? filePort ?? DEFAULT_PORT;
-  const sessionsDir = path21.resolve(
+  const sessionsDir = path23.resolve(
     configDir,
     expandHome(overrideSessionsDir ?? fileSessionsDir ?? DEFAULT_SESSIONS_DIR)
   );
@@ -169261,15 +169278,15 @@ async function probeCompatibleServer(host, port) {
   return null;
 }
 function getOrbhServerStatePaths(cwd) {
-  const serverDir = path23.join(path23.resolve(cwd), SERVER_DIRNAME);
+  const serverDir = path24.join(path24.resolve(cwd), SERVER_DIRNAME);
   return {
-    pidFilePath: path23.join(serverDir, PID_FILENAME),
-    stateFilePath: path23.join(serverDir, STATE_FILENAME2)
+    pidFilePath: path24.join(serverDir, PID_FILENAME),
+    stateFilePath: path24.join(serverDir, STATE_FILENAME2)
   };
 }
 async function writeOrbhServerState(config, state) {
   const paths = getOrbhServerStatePaths(config.cwd);
-  await mkdir16(path23.dirname(paths.pidFilePath), { recursive: true });
+  await mkdir16(path24.dirname(paths.pidFilePath), { recursive: true });
   await writeFile12(paths.pidFilePath, `${state.pid}
 `, "utf-8");
   await writeFile12(paths.stateFilePath, JSON.stringify({
@@ -169375,25 +169392,25 @@ function isRecord9(value) {
 function normalizeKey(value) {
   return value.replace(/[^a-zA-Z0-9]/g, "").toLowerCase();
 }
-function keyMatches(path29, key) {
+function keyMatches(path30, key) {
   const normalizedKey = normalizeKey(key);
   if (!normalizedKey) {
     return false;
   }
-  const normalizedPath = normalizeKey(path29);
+  const normalizedPath = normalizeKey(path30);
   if (normalizedPath === normalizedKey || normalizedPath.endsWith(normalizedKey) || normalizedPath === `${normalizedKey}id`) {
     return true;
   }
-  return path29.split(".").map((part) => normalizeKey(part)).some((part) => part === normalizedKey || part === `${normalizedKey}id`);
+  return path30.split(".").map((part) => normalizeKey(part)).some((part) => part === normalizedKey || part === `${normalizedKey}id`);
 }
-function collectScalarMatches(value, path29, matches) {
+function collectScalarMatches(value, path30, matches) {
   if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
-    matches.push({ path: path29, value: String(value) });
+    matches.push({ path: path30, value: String(value) });
     return;
   }
   if (Array.isArray(value)) {
     value.forEach((entry, index) => {
-      collectScalarMatches(entry, `${path29}.${index}`, matches);
+      collectScalarMatches(entry, `${path30}.${index}`, matches);
     });
     return;
   }
@@ -169401,7 +169418,7 @@ function collectScalarMatches(value, path29, matches) {
     return;
   }
   for (const [key, entry] of Object.entries(value)) {
-    const nextPath = path29 ? `${path29}.${key}` : key;
+    const nextPath = path30 ? `${path30}.${key}` : key;
     collectScalarMatches(entry, nextPath, matches);
   }
 }
@@ -172749,7 +172766,7 @@ function createStandaloneOrbhCommand() {
   });
   return command;
 }
-var __dirname5 = dirname12(fileURLToPath5(import.meta.url));
+var __dirname5 = dirname12(fileURLToPath6(import.meta.url));
 var pkg2 = JSON.parse(readFileSync14(join36(__dirname5, "..", "package.json"), "utf-8"));
 function createStandaloneOrbhProgram() {
   return createStandaloneOrbhCommand().version(formatVersion(pkg2.version ?? "0.0.0", "orbh"));
@@ -173909,7 +173926,7 @@ var tinderboxCommand = new Command("tinderbox").description("Orchestrate operati
 // src/commands/server/server.ts
 init_dist4();
 import { createRequire as createRequire2 } from "module";
-import path27 from "path";
+import path28 from "path";
 import { spawn as spawn11 } from "child_process";
 import { stat as stat21 } from "fs/promises";
 
@@ -174492,8 +174509,8 @@ var FlintServerClient = class {
     }
     return url;
   }
-  async requestRaw(method, path29, options3 = {}) {
-    const url = this.buildUrl(path29, options3.query);
+  async requestRaw(method, path30, options3 = {}) {
+    const url = this.buildUrl(path30, options3.query);
     const headers = new Headers(this.baseHeaders);
     if (options3.headers) {
       const extra = new Headers(options3.headers);
@@ -174514,8 +174531,8 @@ var FlintServerClient = class {
     }
     return response;
   }
-  async requestJson(method, path29, options3 = {}) {
-    const response = await this.requestRaw(method, path29, options3);
+  async requestJson(method, path30, options3 = {}) {
+    const response = await this.requestRaw(method, path30, options3);
     return response.json();
   }
 };
@@ -174579,14 +174596,14 @@ import fastifyCors from "@fastify/cors";
 import fastifyStatic from "@fastify/static";
 import { stat as stat53 } from "fs/promises";
 import path72 from "path";
-import { fileURLToPath as fileURLToPath6 } from "url";
+import { fileURLToPath as fileURLToPath7 } from "url";
 import { join as join54 } from "path";
 import { readdirSync as readdirSync22, existsSync as existsSync43 } from "fs";
 import { randomUUID as randomUUID10, createHash as createHash3 } from "crypto";
 import { EventEmitter as EventEmitter2 } from "events";
 import { readFile as readFile18, stat as stat20 } from "fs/promises";
 import { spawn as spawn10 } from "child_process";
-import path25 from "path";
+import path26 from "path";
 import chokidar from "chokidar";
 import { glob } from "glob";
 
@@ -175394,11 +175411,11 @@ var qmarksTestNoExtDot = ([$0]) => {
   return (f) => f.length === len && f !== "." && f !== "..";
 };
 var defaultPlatform = typeof process === "object" && process ? typeof process.env === "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix";
-var path24 = {
+var path25 = {
   win32: { sep: "\\" },
   posix: { sep: "/" }
 };
-var sep4 = defaultPlatform === "win32" ? path24.win32.sep : path24.posix.sep;
+var sep4 = defaultPlatform === "win32" ? path25.win32.sep : path25.posix.sep;
 minimatch.sep = sep4;
 var GLOBSTAR = /* @__PURE__ */ Symbol("globstar **");
 minimatch.GLOBSTAR = GLOBSTAR;
@@ -176128,7 +176145,7 @@ init_dist();
 import { parse as parseYaml6 } from "yaml";
 import { existsSync as existsSync19, watch as watch4 } from "fs";
 import { stat as stat25 } from "fs/promises";
-import path26 from "path";
+import path27 from "path";
 import { mkdir as mkdir19, readFile as readFile27, writeFile as writeFile15 } from "fs/promises";
 import { homedir as homedir12 } from "os";
 import { join as join41, resolve as resolve17 } from "path";
@@ -176151,7 +176168,7 @@ import { writeFile as writeFile35, mkdir as mkdir33, readdir as readdir43, readF
 import { join as join46 } from "path";
 var DEFAULT_EVENT_LOG_SIZE = 200;
 function computeRuntimeId(flintPath) {
-  const resolved = path25.resolve(flintPath);
+  const resolved = path26.resolve(flintPath);
   return createHash3("sha1").update(resolved).digest("hex").slice(0, 10);
 }
 function createRuntime(options3) {
@@ -176171,8 +176188,8 @@ var FlintRuntimeImpl = class {
   sessionCache = /* @__PURE__ */ new Map();
   startedAt = null;
   constructor(options3) {
-    this.flintPath = path25.resolve(options3.flintPath);
-    this.hooksPath = options3.hooksPath ? path25.resolve(options3.hooksPath) : path25.join(this.flintPath, "flint-hooks.toml");
+    this.flintPath = path26.resolve(options3.flintPath);
+    this.hooksPath = options3.hooksPath ? path26.resolve(options3.hooksPath) : path26.join(this.flintPath, "flint-hooks.toml");
     this.id = computeRuntimeId(this.flintPath);
     this.eventLogSize = options3.eventLogSize ?? DEFAULT_EVENT_LOG_SIZE;
     this.logger = options3.logger ?? {
@@ -176194,7 +176211,7 @@ var FlintRuntimeImpl = class {
     }
     await this.reloadHooks();
     await this.seedCaches();
-    const relativeHooksPath = path25.relative(this.flintPath, this.hooksPath);
+    const relativeHooksPath = path26.relative(this.flintPath, this.hooksPath);
     const watchPatterns = [
       "Mesh/**/*.md",
       ".orbh/sessions/*.json",
@@ -176263,7 +176280,7 @@ var FlintRuntimeImpl = class {
       sessionFiles.map(async (filePath) => {
         const snapshot = await this.readSessionSnapshot(filePath);
         if (snapshot) {
-          const sessionId = path25.basename(filePath, ".json");
+          const sessionId = path26.basename(filePath, ".json");
           this.sessionCache.set(sessionId, snapshot);
         }
       })
@@ -176271,7 +176288,7 @@ var FlintRuntimeImpl = class {
   }
   async handleWatchEvent(event, filePath) {
     const normalized = normalizePath2(filePath);
-    if (normalized === normalizePath2(path25.relative(this.flintPath, this.hooksPath))) {
+    if (normalized === normalizePath2(path26.relative(this.flintPath, this.hooksPath))) {
       if (event === "change") {
         this.logger.info?.("Reloading hooks config");
         await this.reloadHooks();
@@ -176288,7 +176305,7 @@ var FlintRuntimeImpl = class {
     }
     if (normalized.startsWith(".orbh/sessions/")) {
       if (event === "unlink") {
-        const sessionId = path25.basename(normalized, ".json");
+        const sessionId = path26.basename(normalized, ".json");
         this.sessionCache.delete(sessionId);
         return;
       }
@@ -176305,7 +176322,7 @@ var FlintRuntimeImpl = class {
     this.frontmatterCache.set(relativePath, snapshot);
     await this.emitEvent("FileChanged", {
       path: relativePath,
-      absolutePath: path25.join(this.flintPath, relativePath),
+      absolutePath: path26.join(this.flintPath, relativePath),
       frontmatter: snapshot,
       previousFrontmatter: previous ?? null
     });
@@ -176315,7 +176332,7 @@ var FlintRuntimeImpl = class {
     if (previous.status !== snapshot.status) {
       await this.emitEvent("StatusChanged", {
         path: relativePath,
-        absolutePath: path25.join(this.flintPath, relativePath),
+        absolutePath: path26.join(this.flintPath, relativePath),
         field: "status",
         from: previous.status ?? null,
         to: snapshot.status ?? null,
@@ -176327,7 +176344,7 @@ var FlintRuntimeImpl = class {
     for (const tag3 of addedTags) {
       await this.emitEvent("TagAdded", {
         path: relativePath,
-        absolutePath: path25.join(this.flintPath, relativePath),
+        absolutePath: path26.join(this.flintPath, relativePath),
         tag: tag3,
         tags: snapshot.tags
       });
@@ -176335,7 +176352,7 @@ var FlintRuntimeImpl = class {
     for (const tag3 of removedTags) {
       await this.emitEvent("TagRemoved", {
         path: relativePath,
-        absolutePath: path25.join(this.flintPath, relativePath),
+        absolutePath: path26.join(this.flintPath, relativePath),
         tag: tag3,
         tags: snapshot.tags
       });
@@ -176346,7 +176363,7 @@ var FlintRuntimeImpl = class {
     if (!snapshot) {
       return;
     }
-    const sessionId = path25.basename(relativePath, ".json");
+    const sessionId = path26.basename(relativePath, ".json");
     const previous = this.sessionCache.get(sessionId);
     this.sessionCache.set(sessionId, snapshot);
     if (!previous && snapshot.status === "active") {
@@ -176412,7 +176429,7 @@ var FlintRuntimeImpl = class {
     }
   }
   async readFrontmatterSnapshot(relativePath) {
-    const absolutePath = path25.join(this.flintPath, relativePath);
+    const absolutePath = path26.join(this.flintPath, relativePath);
     const content = await safeReadFile(absolutePath);
     if (!content) {
       return null;
@@ -176423,7 +176440,7 @@ var FlintRuntimeImpl = class {
     return { status, tags };
   }
   async readSessionSnapshot(relativePath) {
-    const absolutePath = path25.join(this.flintPath, relativePath);
+    const absolutePath = path26.join(this.flintPath, relativePath);
     const content = await safeReadFile(absolutePath);
     if (!content) {
       return null;
@@ -176541,15 +176558,15 @@ async function executeHook(options3) {
   logger.debug?.("Running hook", hook.command);
   await new Promise((resolve23, reject) => {
     const envPathEntries = [
-      path25.join(flintPath, "node_modules", ".bin"),
-      path25.join(process.cwd(), "node_modules", ".bin"),
+      path26.join(flintPath, "node_modules", ".bin"),
+      path26.join(process.cwd(), "node_modules", ".bin"),
       process.env.PATH
     ].filter(Boolean);
     const child = spawn10(command, {
       cwd: flintPath,
       env: {
         ...process.env,
-        PATH: envPathEntries.join(path25.delimiter)
+        PATH: envPathEntries.join(path26.delimiter)
       },
       shell: true,
       stdio: ["pipe", "pipe", "pipe"],
@@ -176617,11 +176634,11 @@ function resolveHookCommand(command, flintPath) {
   const parts = trimmed.split(/\s+/);
   const target = parts[0] ?? "";
   const rest = parts.slice(1).join(" ");
-  const extension = path25.extname(target);
+  const extension = path26.extname(target);
   if (!extension) {
     return trimmed;
   }
-  const resolvedTarget = path25.isAbsolute(target) ? target : path25.join(flintPath, target);
+  const resolvedTarget = path26.isAbsolute(target) ? target : path26.join(flintPath, target);
   const quotedTarget = quoteIfNeeded(resolvedTarget);
   const suffix = rest ? ` ${rest}` : "";
   if (extension === ".ts") {
@@ -176659,15 +176676,15 @@ var CONTENT_TYPES = {
   ".woff2": "font/woff2"
 };
 function contentTypeFor(filePath) {
-  return CONTENT_TYPES[path26.extname(filePath).toLowerCase()] ?? "application/octet-stream";
+  return CONTENT_TYPES[path27.extname(filePath).toLowerCase()] ?? "application/octet-stream";
 }
 function isImmutableAsset(filePath) {
-  return /\.[a-f0-9]{8,}\./i.test(path26.basename(filePath));
+  return /\.[a-f0-9]{8,}\./i.test(path27.basename(filePath));
 }
 async function resolveFlintPath5(inputPath) {
-  const resolved = path26.resolve(inputPath);
-  const flintToml = path26.join(resolved, "flint.toml");
-  const flintState = path26.join(resolved, ".flint");
+  const resolved = path27.resolve(inputPath);
+  const flintToml = path27.join(resolved, "flint.toml");
+  const flintState = path27.join(resolved, ".flint");
   const hasConfig = await exists5(flintToml);
   const hasState = await exists5(flintState);
   if (!hasConfig && !hasState) {
@@ -178302,7 +178319,7 @@ async function startFlintServer(options3 = {}) {
     suppressedPaths,
     suppressPath
   };
-  const __dirname7 = path72.dirname(fileURLToPath6(import.meta.url));
+  const __dirname7 = path72.dirname(fileURLToPath7(import.meta.url));
   const dashboardDist = path72.resolve(__dirname7, "..", "..", "..", "apps", "flint-dashboard", "dist");
   try {
     await stat53(dashboardDist);
@@ -178610,12 +178627,12 @@ serverCommand.command("dev").description(
     const serverPkgJson = require3.resolve(
       `${FLINT_SERVER_PACKAGE}/package.json`
     );
-    serverPkgDir = path27.dirname(serverPkgJson);
+    serverPkgDir = path28.dirname(serverPkgJson);
   } catch {
     console.error(export_pc.red("Error: flint-server package not found."));
     process.exit(1);
   }
-  const devEntry = path27.join(serverPkgDir, "src", "dev.ts");
+  const devEntry = path28.join(serverPkgDir, "src", "dev.ts");
   try {
     await stat21(devEntry);
   } catch {
@@ -178737,10 +178754,10 @@ serverCommand.command("list").description("List all running Flint servers from t
 init_dist4();
 import { readFile as readFile19, readdir as readdir17, rm as rm14 } from "fs/promises";
 import { join as join47 } from "path";
-async function exists6(path29) {
+async function exists6(path30) {
   try {
     const { stat: stat26 } = await import("fs/promises");
-    await stat26(path29);
+    await stat26(path30);
     return true;
   } catch {
     return false;
@@ -179338,12 +179355,12 @@ var helperCommand = new Command("helper").description("Helper utilities for Flin
 
 // src/commands/system/runtime.ts
 init_dist4();
-import path28 from "path";
+import path29 from "path";
 var runtimeCommand = new Command("runtime").description("Manage Flint runtimes");
 runtimeCommand.command("start [flintPath]").description("Start runtime for a Flint").option("--server <url>", "Server URL", "http://127.0.0.1:13040").action(async (flintPath, options3) => {
   const serverUrl = options3.server;
   const client = new FlintServerClient({ baseUrl: serverUrl });
-  const resolvedPath = flintPath ? path28.resolve(flintPath) : await findFlintRoot(process.cwd());
+  const resolvedPath = flintPath ? path29.resolve(flintPath) : await findFlintRoot(process.cwd());
   if (!resolvedPath) {
     console.error(export_pc.red("Error: Not inside a Flint workspace. Provide a path or cd into one."));
     process.exit(1);
@@ -179367,7 +179384,7 @@ runtimeCommand.command("stop [runtimeId]").description("Stop a running runtime")
   let id = runtimeId;
   try {
     if (!id) {
-      const lookupPath = options3.path ? path28.resolve(options3.path) : await findFlintRoot(process.cwd());
+      const lookupPath = options3.path ? path29.resolve(options3.path) : await findFlintRoot(process.cwd());
       if (!lookupPath) {
         console.error(export_pc.red("Error: Provide a runtime ID or Flint path."));
         process.exit(1);
@@ -179443,7 +179460,7 @@ var whoamiCommand = new Command("whoami").description("Show the current person i
 
 // src/index.ts
 registerAllFeatures();
-var __dirname6 = dirname13(fileURLToPath7(import.meta.url));
+var __dirname6 = dirname13(fileURLToPath8(import.meta.url));
 var pkg3 = JSON.parse(readFileSync18(join49(__dirname6, "..", "package.json"), "utf-8"));
 var profile = getBuildMode("flint");
 await runCliMigrations({