@evo-dev/core 0.0.1-alpha.12 → 0.0.1-alpha.14

package/dist/config/index.js

@@ -117,7 +117,25 @@ function expectString(value, path) {
   return value;
 }
 // packages/core/src/config/settings.ts
-import { readFile as readFile2 } from "node:fs/promises";
+import { readFile as readFile3 } from "node:fs/promises";
+
+// packages/core/src/utils/errors.ts
+function isNotFoundError(error) {
+  return error instanceof Error && (("code" in error) && error.code === "ENOENT" || error.message.includes("ENOENT"));
+}
+// packages/core/src/utils/hash.ts
+import { createHash } from "node:crypto";
+function sha256Hex(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+function sha256Short(value, length = 16) {
+  return sha256Hex(value).slice(0, length);
+}
+// packages/core/src/utils/ids.ts
+function sanitizeStorageId(value, fallbackPrefix) {
+  const sanitized = value.replace(/[^a-zA-Z0-9._-]/g, "-").slice(0, 120);
+  return sanitized === "" || sanitized === "." || sanitized === ".." ? `${fallbackPrefix}-local` : sanitized;
+}
 // packages/core/src/utils/parsing.ts
 function optionalBoolean(value, fallback) {
   return typeof value === "boolean" ? value : fallback;
@@ -250,7 +268,13 @@ function parseSessionMemoryPolicy(value) {
     toolCallsBetweenUpdates: positiveInteger(value.toolCallsBetweenUpdates, defaults.toolCallsBetweenUpdates)
   };
 }
+// packages/core/src/projects/index.ts
+import { lstat, readFile, readdir, realpath, stat } from "node:fs/promises";
+import { basename as basename2, dirname as dirname2, isAbsolute as isAbsolute2, join as join2, parse } from "node:path";
+
 // packages/core/src/runtime-logs/index.ts
+import { lstatSync, readFileSync, realpathSync } from "node:fs";
+import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
 var SAFE_EXECUTION_METADATA_KEYS = new Set([
   "phase",
   "runtimeSurface",
@@ -266,6 +290,7 @@ var SAFE_EXECUTION_METADATA_KEYS = new Set([
   "redactionLabels",
   "normalizedEventType"
 ]);
+var SENSITIVE_EVENT_TEXT_PATTERN = /https?:\/\/\S+|(^|[^a-z0-9])(secret|token|password|passwd|private|internal|api[_-]?key|apikey|credential|credentials|stdout|stderr|transcript|formattedresponse|additionalcontext)([^a-z0-9]|$)|raw[\s_-]?(payload|prompt|output|source)|source[\s_-]?dump/i;
 var SAFE_REDACTION_LABELS = new Set([
   "raw-command",
   "raw-command-output",
@@ -273,12 +298,335 @@ var SAFE_REDACTION_LABELS = new Set([
   "sensitive-command",
   "sensitive-text"
 ]);
+function resolveProjectLogIdentity(homeDir, repoRoot) {
+  const identityHomeDir = realpathDirectoryOrFallback(homeDir);
+  const workspaceRoot = realpathDirectoryOrFallback(repoRoot);
+  const workspaceKey = resolvePathProjectLogKey(identityHomeDir, workspaceRoot);
+  const gitCommonDir = resolveGitCommonDir(workspaceRoot);
+  if (gitCommonDir === null) {
+    return {
+      projectKey: workspaceKey,
+      workspaceKey,
+      projectRoot: workspaceRoot,
+      workspaceRoot,
+      gitCommonDir: null,
+      linkedWorktree: false
+    };
+  }
+  const commonDirOwnsWorktree = basename(gitCommonDir) === ".git";
+  const projectIdentityPath = commonDirOwnsWorktree ? dirname(gitCommonDir) : gitCommonDir;
+  const projectRoot = commonDirOwnsWorktree ? projectIdentityPath : workspaceRoot;
+  return {
+    projectKey: resolvePathProjectLogKey(identityHomeDir, projectIdentityPath),
+    workspaceKey,
+    projectRoot,
+    workspaceRoot,
+    gitCommonDir,
+    linkedWorktree: workspaceKey !== resolvePathProjectLogKey(identityHomeDir, projectIdentityPath)
+  };
+}
+function resolvePathProjectLogKey(homeDir, repoRoot) {
+  const trimmedHome = stripTrailingSlash2(homeDir);
+  const trimmedRepo = stripTrailingSlash2(repoRoot);
+  const relativePath = relative(trimmedHome, trimmedRepo);
+  const source = relativePath !== "" && !relativePath.startsWith("..") && !isAbsolute(relativePath) ? relativePath : trimmedRepo.replace(/^[/\\]+/, "");
+  const projectKey = source.split(/[/\\]+/).filter(Boolean).map((part) => sanitizePathSegment(part)).join("-") || "project-local";
+  return sanitizePersistentIdentifier(projectKey, "project");
+}
+function realpathDirectoryOrFallback(path) {
+  try {
+    return realpathSync(path);
+  } catch {
+    if (!isAbsolute(path))
+      return stripTrailingSlash2(path);
+    const missingSegments = [];
+    let current = stripTrailingSlash2(path);
+    for (;; ) {
+      const parent = dirname(current);
+      if (parent === current)
+        return stripTrailingSlash2(path);
+      missingSegments.unshift(basename(current));
+      current = parent;
+      try {
+        return join(realpathSync(current), ...missingSegments);
+      } catch {}
+    }
+  }
+}
+function resolveGitCommonDir(workspaceRoot) {
+  const markerPath = join(workspaceRoot, ".git");
+  let gitDir;
+  try {
+    const marker = lstatSync(markerPath);
+    if (marker.isDirectory()) {
+      gitDir = realpathSync(markerPath);
+    } else if (marker.isFile()) {
+      const value = readFileSync(markerPath, "utf8").trim();
+      const match = value.match(/^gitdir:\s*(.+)$/u);
+      if (match?.[1] === undefined || match[1].includes("\x00"))
+        return null;
+      gitDir = realpathSync(isAbsolute(match[1]) ? match[1] : resolve(workspaceRoot, match[1]));
+    } else {
+      return null;
+    }
+  } catch {
+    return null;
+  }
+  try {
+    const commonDirValue = readFileSync(join(gitDir, "commondir"), "utf8").trim();
+    if (commonDirValue === "" || commonDirValue.includes("\x00"))
+      return gitDir;
+    return realpathSync(isAbsolute(commonDirValue) ? commonDirValue : resolve(gitDir, commonDirValue));
+  } catch {
+    return gitDir;
+  }
+}
+function sanitizePathSegment(value) {
+  return value.replace(/[^a-zA-Z0-9._-]/g, "-").slice(0, 120) || "session-local";
+}
+function sanitizePersistentIdentifier(value, prefix) {
+  const pathSafe = value.replace(/[^a-zA-Z0-9._-]/g, "-").slice(0, 120) || `${prefix}-local`;
+  if (!SENSITIVE_EVENT_TEXT_PATTERN.test(value) && !SENSITIVE_EVENT_TEXT_PATTERN.test(pathSafe)) {
+    return pathSafe;
+  }
+  return `${prefix}-${sha256Short(value)}`;
+}
+function stripTrailingSlash2(path) {
+  if (path === "/" || /^[A-Za-z]:[\\/]?$/.test(path))
+    return path;
+  return path.replace(/[/\\]+$/, "");
+}
+
+// packages/core/src/projects/index.ts
+class ProjectRegistrationError extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "ProjectRegistrationError";
+    this.code = code;
+  }
+}
+function resolveProjectRegistryPaths(homeDir) {
+  const paths = resolveEvoDevPaths(homeDir);
+  const discoveredDir = join2(paths.stateDir, "projects", "discovered");
+  const registeredDir = join2(paths.rootDir, "projects");
+  const workspaceDir = join2(paths.stateDir, "projects", "workspaces");
+  const aliasDir = join2(paths.stateDir, "projects", "aliases");
+  return {
+    discoveredDir,
+    registeredDir,
+    workspaceDir,
+    aliasDir,
+    discoveredPath: (projectKey) => join2(discoveredDir, `${projectKey}.json`),
+    registeredPath: (projectKey) => join2(registeredDir, projectKey, "workspace.json"),
+    workspacePath: (workspaceKey) => join2(workspaceDir, `${workspaceKey}.json`),
+    aliasPath: (aliasProjectKey) => join2(aliasDir, `${aliasProjectKey}.json`)
+  };
+}
+async function resolveProjectWorkspaceFromCwd(input) {
+  if (!isAbsolute2(input.cwd))
+    return null;
+  let cwd;
+  try {
+    const info = await stat(input.cwd);
+    if (!info.isDirectory())
+      return null;
+    cwd = await realpath(input.cwd);
+  } catch (error) {
+    if (isNotFoundError(error))
+      return null;
+    throw error;
+  }
+  const gitRoot = await findNearestGitRoot(cwd);
+  const workspaceRoot = gitRoot ?? cwd;
+  const identity = resolveProjectLogIdentity(input.homeDir, workspaceRoot);
+  return {
+    projectKey: sanitizeStorageId(identity.projectKey, "project"),
+    workspaceKey: sanitizeStorageId(identity.workspaceKey, "workspace"),
+    displayName: basename2(identity.projectRoot) || parse(identity.projectRoot).root,
+    projectRoot: identity.projectRoot,
+    workspaceRoot,
+    workspaceKind: gitRoot === null ? "directory" : "git",
+    gitCommonDir: identity.gitCommonDir,
+    linkedWorktree: identity.linkedWorktree,
+    cwd
+  };
+}
+async function listProjectAliases(input) {
+  const paths = resolveProjectRegistryPaths(input.homeDir);
+  const aliases = {};
+  for (const path of await listJsonFilePaths(paths.aliasDir)) {
+    const record = await readProjectAlias(path);
+    if (record !== null)
+      aliases[record.aliasProjectKey] = record.canonicalProjectKey;
+  }
+  for (const path of await listJsonFilePaths(paths.discoveredDir)) {
+    const record = await readDiscoveredProject(path);
+    if (record !== null) {
+      await collectAvailableProjectAlias(input.homeDir, record, aliases);
+    }
+  }
+  for (const projectKey of await listDirectoryNames2(paths.registeredDir)) {
+    const record = await readRegisteredProject(join2(paths.registeredDir, projectKey, "workspace.json"));
+    if (record !== null) {
+      await collectAvailableProjectAlias(input.homeDir, record, aliases);
+    }
+  }
+  return normalizeProjectAliases(aliases);
+}
+function canonicalizeProjectKey(projectKey, aliases) {
+  let current = projectKey;
+  const seen = new Set;
+  while (!seen.has(current)) {
+    seen.add(current);
+    const next = aliases[current];
+    if (next === undefined || next === current)
+      return current;
+    current = next;
+  }
+  return projectKey;
+}
+async function listEquivalentProjectKeys(input) {
+  const aliases = await listProjectAliases({ homeDir: input.homeDir });
+  const canonical = canonicalizeProjectKey(input.projectKey, aliases);
+  return [
+    ...new Set([
+      canonical,
+      input.projectKey,
+      ...Object.keys(aliases).filter((alias) => canonicalizeProjectKey(alias, aliases) === canonical)
+    ])
+  ].sort();
+}
+async function collectAvailableProjectAlias(homeDir, record, aliases) {
+  const workspace = await resolveProjectWorkspaceFromCwd({
+    homeDir,
+    cwd: record.workspaceRoot
+  }).catch(() => null);
+  if (workspace === null)
+    return;
+  if (record.projectKey !== workspace.projectKey) {
+    aliases[record.projectKey] = workspace.projectKey;
+  }
+  if (workspace.workspaceKey !== workspace.projectKey) {
+    aliases[workspace.workspaceKey] = workspace.projectKey;
+  }
+}
+function normalizeProjectAliases(aliases) {
+  return Object.fromEntries(Object.keys(aliases).sort().flatMap((alias) => {
+    const canonical = canonicalizeProjectKey(alias, aliases);
+    return canonical === alias ? [] : [[alias, canonical]];
+  }));
+}
+async function findNearestGitRoot(cwd) {
+  let current = cwd;
+  for (;; ) {
+    try {
+      const marker = await lstat(join2(current, ".git"));
+      if (marker.isDirectory() || marker.isFile())
+        return current;
+    } catch (error) {
+      if (!isNotFoundError(error))
+        throw error;
+    }
+    const parent = dirname2(current);
+    if (parent === current)
+      return null;
+    current = parent;
+  }
+}
+async function readDiscoveredProject(path) {
+  try {
+    return parseDiscoveredProject(JSON.parse(await readFile(path, "utf8")));
+  } catch (error) {
+    if (isNotFoundError(error) || error instanceof ProjectRegistrationError)
+      return null;
+    throw error;
+  }
+}
+async function readRegisteredProject(path) {
+  try {
+    return parseRegisteredProject(JSON.parse(await readFile(path, "utf8")));
+  } catch (error) {
+    if (isNotFoundError(error) || error instanceof ProjectRegistrationError)
+      return null;
+    throw error;
+  }
+}
+async function readProjectAlias(path) {
+  try {
+    return parseProjectAlias(JSON.parse(await readFile(path, "utf8")));
+  } catch (error) {
+    if (isNotFoundError(error) || error instanceof ProjectRegistrationError)
+      return null;
+    throw error;
+  }
+}
+function parseDiscoveredProject(value) {
+  const record = requireRecord(value);
+  if (record.schemaVersion !== 1 || record.kind !== "discovered-project" || !isProjectKey(record.projectKey) || !isNonEmptyString(record.displayName) || !isAbsoluteString(record.workspaceRoot) || !isAbsoluteString(record.lastCwd) || !isWorkspaceKind(record.workspaceKind) || !isDiscoveryTargetArray(record.sourceTargets) || !(record.lastSessionKey === null || isNonEmptyString(record.lastSessionKey)) || !isNonEmptyString(record.firstSeenAt) || !isNonEmptyString(record.lastSeenAt) || record.localOnly !== true || record.sourceContentStored !== false) {
+    throw new ProjectRegistrationError("invalid", "Discovered project record is invalid.");
+  }
+  return record;
+}
+function parseRegisteredProject(value) {
+  const record = requireRecord(value);
+  if (record.schemaVersion !== 1 || record.kind !== "registered-project" || !isProjectKey(record.projectKey) || !isNonEmptyString(record.displayName) || !isAbsoluteString(record.workspaceRoot) || !isWorkspaceKind(record.workspaceKind) || !isNonEmptyString(record.registeredAt) || !isNonEmptyString(record.lastSeenAt) || record.localOnly !== true || record.sourceContentStored !== false) {
+    throw new ProjectRegistrationError("invalid", "Registered project record is invalid.");
+  }
+  return record;
+}
+function parseProjectAlias(value) {
+  const record = requireRecord(value);
+  if (record.schemaVersion !== 1 || record.kind !== "project-alias" || !isProjectKey(record.aliasProjectKey) || !isProjectKey(record.canonicalProjectKey) || record.aliasProjectKey === record.canonicalProjectKey || !isAbsoluteString(record.workspaceRoot) || !isNonEmptyString(record.createdAt) || !isNonEmptyString(record.updatedAt) || record.localOnly !== true || record.sourceContentStored !== false) {
+    throw new ProjectRegistrationError("invalid", "Project alias record is invalid.");
+  }
+  return record;
+}
+async function listJsonFilePaths(path) {
+  try {
+    return (await readdir(path, { withFileTypes: true })).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => join2(path, entry.name)).sort();
+  } catch (error) {
+    if (isNotFoundError(error))
+      return [];
+    throw error;
+  }
+}
+async function listDirectoryNames2(path) {
+  try {
+    return (await readdir(path, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
+  } catch (error) {
+    if (isNotFoundError(error))
+      return [];
+    throw error;
+  }
+}
+function isProjectKey(value) {
+  return typeof value === "string" && value !== "." && value !== ".." && /^[A-Za-z0-9._-]{1,120}$/.test(value);
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim() !== "";
+}
+function isAbsoluteString(value) {
+  return isNonEmptyString(value) && isAbsolute2(value);
+}
+function isWorkspaceKind(value) {
+  return value === "git" || value === "directory";
+}
+function isDiscoveryTargetArray(value) {
+  return Array.isArray(value) && value.length > 0 && value.every((item) => item === "claude" || item === "codex");
+}
+function requireRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new ProjectRegistrationError("invalid", "Project record must be an object.");
+  }
+  return value;
+}
 
 // packages/core/src/evolution/evidence/session-memory/constants.ts
 var DEFAULT_MAX_RAW_EVENT_BYTES = 64 * 1024;
 // packages/core/src/evolution/knowledge/index.ts
-import { mkdir, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
-import { dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { mkdir, readFile as readFile2, readdir as readdir2, rename, rm, stat as stat2, writeFile } from "node:fs/promises";
+import { dirname as dirname3, isAbsolute as isAbsolute3, join as join3, relative as relative2, resolve as resolve2 } from "node:path";
 var RESERVED_OKF_FILENAMES = new Set(["index.md", "log.md"]);
 var ACTIVE_OKF_REVIEW_STATES = ["accepted", "auto-accepted"];
 var OKF_REVIEW_STATES = [
@@ -313,9 +661,9 @@ function resolveOkfKnowledgePaths(homeDir) {
   const paths2 = resolveEvoDevPaths(homeDir);
   return {
     knowledgeDir: paths2.knowledgeDir,
-    okfDir: join(paths2.knowledgeDir, "okf"),
-    indexesDir: join(paths2.knowledgeDir, "indexes"),
-    tmpDir: join(paths2.knowledgeDir, "tmp")
+    okfDir: join3(paths2.knowledgeDir, "okf"),
+    indexesDir: join3(paths2.knowledgeDir, "indexes"),
+    tmpDir: join3(paths2.knowledgeDir, "tmp")
   };
 }
 async function ensureOkfKnowledgeBase(homeDir) {
@@ -375,11 +723,11 @@ async function rebuildOkfKnowledgeIndexes(input) {
     pathScopes: concept.pathScopes
   }));
   const pathsWritten = [
-    join(paths2.indexesDir, "index.json"),
-    join(paths2.indexesDir, "concepts.json"),
-    join(paths2.indexesDir, "repos.json"),
-    join(paths2.indexesDir, "roles.json"),
-    join(paths2.indexesDir, "workflows.json")
+    join3(paths2.indexesDir, "index.json"),
+    join3(paths2.indexesDir, "concepts.json"),
+    join3(paths2.indexesDir, "repos.json"),
+    join3(paths2.indexesDir, "roles.json"),
+    join3(paths2.indexesDir, "workflows.json")
   ];
   await writeJson2(pathsWritten[0], {
     schemaVersion: 1,
@@ -413,31 +761,35 @@ async function listOkfKnowledgeConcepts(input) {
   const okfDir = resolveOkfKnowledgePaths(input.homeDir).okfDir;
   if (!await pathExists2(okfDir))
     return [];
+  const equivalentProjectKeys = input.projectKey === undefined ? undefined : await listEquivalentProjectKeys({
+    homeDir: input.homeDir,
+    projectKey: input.projectKey
+  });
   const files = await listMarkdownFiles(okfDir);
   const concepts = [];
   for (const file of files) {
     if (RESERVED_OKF_FILENAMES.has(file.name))
       continue;
-    const content = await readFile(file.path, "utf8");
+    const content = await readFile2(file.path, "utf8");
     const parsed = parseOkfConceptFile(okfDir, file.path, content);
     if (parsed !== null)
       concepts.push(parsed);
   }
-  return concepts.filter((concept) => matchesConceptFilters(concept, input)).sort((left, right) => left.id.localeCompare(right.id));
+  return concepts.filter((concept) => matchesConceptFilters(concept, input, equivalentProjectKeys)).sort((left, right) => left.id.localeCompare(right.id));
 }
 async function ensureLocalKnowledgeGitRepository(knowledgeDir) {
   await mkdir(knowledgeDir, { recursive: true });
-  const gitDir = join(knowledgeDir, ".git");
+  const gitDir = join3(knowledgeDir, ".git");
   if (await pathExists2(gitDir))
     return;
-  await mkdir(join(gitDir, "objects", "info"), { recursive: true });
-  await mkdir(join(gitDir, "objects", "pack"), { recursive: true });
-  await mkdir(join(gitDir, "refs", "heads"), { recursive: true });
-  await mkdir(join(gitDir, "refs", "tags"), { recursive: true });
-  await mkdir(join(gitDir, "info"), { recursive: true });
-  await writeTextIfMissing(join(gitDir, "HEAD"), `ref: refs/heads/main
+  await mkdir(join3(gitDir, "objects", "info"), { recursive: true });
+  await mkdir(join3(gitDir, "objects", "pack"), { recursive: true });
+  await mkdir(join3(gitDir, "refs", "heads"), { recursive: true });
+  await mkdir(join3(gitDir, "refs", "tags"), { recursive: true });
+  await mkdir(join3(gitDir, "info"), { recursive: true });
+  await writeTextIfMissing(join3(gitDir, "HEAD"), `ref: refs/heads/main
 `);
-  await writeTextIfMissing(join(gitDir, "config"), [
+  await writeTextIfMissing(join3(gitDir, "config"), [
     "[core]",
     "\trepositoryformatversion = 0",
     "\tfilemode = true",
@@ -446,7 +798,7 @@ async function ensureLocalKnowledgeGitRepository(knowledgeDir) {
     ""
   ].join(`
 `));
-  await writeTextIfMissing(join(gitDir, "info", "exclude"), [
+  await writeTextIfMissing(join3(gitDir, "info", "exclude"), [
     "# EvoDev user-local knowledge git repository.",
     "# No remote is configured by default.",
     ""
@@ -456,7 +808,7 @@ async function ensureLocalKnowledgeGitRepository(knowledgeDir) {
 async function writeTextIfMissing(path, value) {
   if (await pathExists2(path))
     return;
-  await mkdir(dirname(path), { recursive: true });
+  await mkdir(dirname3(path), { recursive: true });
   await writeFile(path, value, { encoding: "utf8", flag: "wx" });
 }
 function sanitizeOkfText(value) {
@@ -466,7 +818,7 @@ async function ensureOkfDirectory(okfDir, relativeDir, title, description) {
   const dir = relativeDir === "" || relativeDir === "." ? okfDir : resolveOkfTargetPath(okfDir, relativeDir);
   await mkdir(dir, { recursive: true });
   const isRoot = dir === okfDir;
-  const indexPath = join(dir, "index.md");
+  const indexPath = join3(dir, "index.md");
   if (!await pathExists2(indexPath)) {
     await writeFile(indexPath, isRoot ? [
       "---",
@@ -483,7 +835,7 @@ async function ensureOkfDirectory(okfDir, relativeDir, title, description) {
 `) : [`# ${title}`, "", description, ""].join(`
 `), "utf8");
   }
-  const logPath = join(dir, "log.md");
+  const logPath = join3(dir, "log.md");
   if (!await pathExists2(logPath)) {
     await writeFile(logPath, [
       "# Directory Update Log",
@@ -539,8 +891,9 @@ function parseOkfConceptFile(okfDir, filePath, content) {
     body: parsed.body
   };
 }
-function matchesConceptFilters(concept, input) {
-  if (input.projectKey !== undefined && concept.repoTags.length > 0 && !concept.repoTags.includes(sanitizeSlug(input.projectKey)) && !concept.tags.includes(`repo:${sanitizeSlug(input.projectKey)}`)) {
+function matchesConceptFilters(concept, input, equivalentProjectKeys) {
+  const projectKeys = (equivalentProjectKeys ?? []).map(sanitizeSlug);
+  if (input.projectKey !== undefined && concept.repoTags.length > 0 && ![sanitizeSlug(input.projectKey), ...projectKeys].some((projectKey) => concept.repoTags.includes(projectKey) || concept.tags.includes(`repo:${projectKey}`))) {
     return false;
   }
   if (input.roleId !== undefined && concept.roleTags.length > 0 && !concept.roleTags.includes(sanitizeSlug(input.roleId)) && !concept.tags.includes(`role:${sanitizeSlug(input.roleId)}`)) {
@@ -761,10 +1114,10 @@ function parseYamlValue(value) {
 async function listMarkdownFiles(root) {
   if (!await pathExists2(root))
     return [];
-  const entries = await readdir(root, { withFileTypes: true });
+  const entries = await readdir2(root, { withFileTypes: true });
   const files = [];
   for (const entry of entries) {
-    const path = join(root, entry.name);
+    const path = join3(root, entry.name);
     if (entry.isDirectory()) {
       files.push(...await listMarkdownFiles(path));
     } else if (entry.isFile() && entry.name.endsWith(".md")) {
@@ -790,14 +1143,14 @@ function resolveOkfTargetPath(okfDir, targetPath) {
   if (clean.split("/").some((segment) => segment === ".." || segment === "." || segment === "")) {
     throw new Error(`Unsafe OKF target path: ${targetPath}`);
   }
-  const resolved = join(okfDir, clean);
-  const rel = relative(okfDir, resolved);
+  const resolved = join3(okfDir, clean);
+  const rel = relative2(okfDir, resolved);
   if (rel.startsWith("..") || rel === "")
     throw new Error(`Unsafe OKF target path: ${targetPath}`);
   return resolved;
 }
 function toOkfRelativePath(okfDir, path) {
-  return relative(okfDir, path).replace(/\\/gu, "/");
+  return relative2(okfDir, path).replace(/\\/gu, "/");
 }
 function sanitizeSlug(value) {
   const slug = value.trim().toLowerCase().replace(/[^a-z0-9._/-]+/gu, "-").replace(/\/+/gu, "/").replace(/^-+|-+$/gu, "");
@@ -813,14 +1166,14 @@ function todayIsoDate() {
   return new Date().toISOString().slice(0, 10);
 }
 async function writeJson2(path, value, options = {}) {
-  await mkdir(dirname(path), { recursive: true });
+  await mkdir(dirname3(path), { recursive: true });
   const flag = options.overwrite === true ? "w" : "wx";
   await writeFile(path, `${JSON.stringify(value, null, 2)}
 `, { encoding: "utf8", flag });
 }
 async function pathExists2(path) {
   try {
-    await stat(path);
+    await stat2(path);
     return true;
   } catch (error) {
     if (error instanceof Error && "code" in error && error.code === "ENOENT")
@@ -1174,7 +1527,7 @@ function mergeSettings(existing, defaults = createDefaultSettings()) {
 async function readRuntimeInjectionSettings(homeDir) {
   const paths2 = resolveEvoDevPaths(homeDir);
   try {
-    return parseSettings(JSON.parse(await readFile2(paths2.settingsPath, "utf8"))).memory;
+    return parseSettings(JSON.parse(await readFile3(paths2.settingsPath, "utf8"))).memory;
   } catch (error) {
     if (isNotFoundError2(error))
       return createDefaultMemorySettings();
@@ -1387,8 +1740,8 @@ function expectNonNegativeInteger(value, path) {
   return value;
 }
 // packages/core/src/config/store.ts
-import { mkdir as mkdir2, readFile as readFile3, writeFile as writeFile2 } from "node:fs/promises";
-import { dirname as dirname2 } from "node:path";
+import { mkdir as mkdir2, readFile as readFile4, writeFile as writeFile2 } from "node:fs/promises";
+import { dirname as dirname4 } from "node:path";
 function createCoreConfigStore(homeDir) {
   const paths2 = resolveEvoDevPaths(homeDir);
   return {
@@ -1518,10 +1871,10 @@ async function ensureKnowledgeBaseFiles(paths2) {
     teams: []
   });
 }
-async function readJsonFile(filePath, parse) {
+async function readJsonFile(filePath, parse2) {
   let raw;
   try {
-    raw = await readFile3(filePath, "utf8");
+    raw = await readFile4(filePath, "utf8");
   } catch (error) {
     throw new EvoDevConfigError(`Cannot read config file (${describeFileError(error)})`, filePath);
   }
@@ -1532,7 +1885,7 @@ async function readJsonFile(filePath, parse) {
     throw new EvoDevConfigError(`Invalid JSON (${describeFileError(error)})`, filePath);
   }
   try {
-    return parse(json);
+    return parse2(json);
   } catch (error) {
     if (error instanceof EvoDevConfigError) {
       throw new EvoDevConfigError(error.message, filePath);
@@ -1540,9 +1893,9 @@ async function readJsonFile(filePath, parse) {
     throw error;
   }
 }
-async function readJsonFileOrDefault(filePath, parse, fallback) {
+async function readJsonFileOrDefault(filePath, parse2, fallback) {
   try {
-    return await readJsonFile(filePath, parse);
+    return await readJsonFile(filePath, parse2);
   } catch (error) {
     if (error instanceof EvoDevConfigError && error.message.includes("ENOENT")) {
       return fallback;
@@ -1552,7 +1905,7 @@ async function readJsonFileOrDefault(filePath, parse, fallback) {
 }
 async function writeIfMissing(filePath, value) {
   try {
-    await readFile3(filePath, "utf8");
+    await readFile4(filePath, "utf8");
   } catch (error) {
     if (isNodeError(error) && error.code === "ENOENT") {
       await writeJsonFile2(filePath, value);
@@ -1564,7 +1917,7 @@ async function writeIfMissing(filePath, value) {
 async function writeIndexIfMissingOrMigrate(filePath, kind, defaults) {
   let raw;
   try {
-    raw = await readFile3(filePath, "utf8");
+    raw = await readFile4(filePath, "utf8");
   } catch (error) {
     if (isNodeError(error) && error.code === "ENOENT") {
       await writeJsonFile2(filePath, defaults);
@@ -1587,10 +1940,10 @@ async function writeIndexIfMissingOrMigrate(filePath, kind, defaults) {
 }
 async function writeTextIfMissing2(filePath, value) {
   try {
-    await readFile3(filePath, "utf8");
+    await readFile4(filePath, "utf8");
   } catch (error) {
     if (isNodeError(error) && error.code === "ENOENT") {
-      await mkdir2(dirname2(filePath), { recursive: true });
+      await mkdir2(dirname4(filePath), { recursive: true });
       await writeFile2(filePath, value, "utf8");
       return;
     }
@@ -1598,7 +1951,7 @@ async function writeTextIfMissing2(filePath, value) {
   }
 }
 async function writeJsonFile2(filePath, value) {
-  await mkdir2(dirname2(filePath), { recursive: true });
+  await mkdir2(dirname4(filePath), { recursive: true });
   await writeFile2(filePath, `${JSON.stringify(value, null, 2)}
 `, "utf8");
 }