@evo-dev/core 0.0.1-alpha.3 → 0.0.1-alpha.5

package/dist/config/index.js

@@ -118,7 +118,41 @@ function expectString(value, path) {
 }
 // packages/core/src/config/settings.ts
 import { readFile as readFile2 } from "node:fs/promises";
-
+// packages/core/src/utils/parsing.ts
+function optionalBoolean(value, fallback) {
+  return typeof value === "boolean" ? value : fallback;
+}
+function positiveInteger(value, fallback) {
+  return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : fallback;
+}
+// packages/core/src/evolution/evidence/session-memory/policy.ts
+function createDefaultSessionMemoryPolicy() {
+  return {
+    enabled: true,
+    storeRawSegments: true,
+    maxRawSegmentBytes: 200000,
+    retentionDays: 30,
+    minimumMessageTokensToInit: 1e4,
+    minimumTokensBetweenUpdate: 5000,
+    toolCallsBetweenUpdates: 9
+  };
+}
+function parseSessionMemoryPolicy(value) {
+  const defaults = createDefaultSessionMemoryPolicy();
+  if (value === undefined)
+    return defaults;
+  return {
+    enabled: optionalBoolean(value.enabled, defaults.enabled),
+    storeRawSegments: optionalBoolean(value.storeRawSegments, defaults.storeRawSegments),
+    maxRawSegmentBytes: positiveInteger(value.maxRawSegmentBytes, defaults.maxRawSegmentBytes),
+    retentionDays: positiveInteger(value.retentionDays, defaults.retentionDays),
+    minimumMessageTokensToInit: positiveInteger(value.minimumMessageTokensToInit, defaults.minimumMessageTokensToInit),
+    minimumTokensBetweenUpdate: positiveInteger(value.minimumTokensBetweenUpdate, defaults.minimumTokensBetweenUpdate),
+    toolCallsBetweenUpdates: positiveInteger(value.toolCallsBetweenUpdates, defaults.toolCallsBetweenUpdates)
+  };
+}
+// packages/core/src/evolution/evidence/session-memory/constants.ts
+var DEFAULT_MAX_RAW_EVENT_BYTES = 64 * 1024;
 // packages/core/src/runtime-logs/index.ts
 var SAFE_EXECUTION_METADATA_KEYS = new Set([
   "phase",
@@ -143,7 +177,44 @@ var SAFE_REDACTION_LABELS = new Set([
   "sensitive-text"
 ]);
 
-// packages/core/src/knowledge/index.ts
+// packages/core/src/evolution/shared.ts
+var MAX_PROPOSED_CHANGE_LENGTH = 16 * 1024;
+var PROCESS_LOCK_STALE_MS = 5 * 60 * 1000;
+var FORBIDDEN_RAW_KEYS = new Set([
+  "commandhistory",
+  "commandoutput",
+  "credential",
+  "credentials",
+  "env",
+  "fullsource",
+  "memorybody",
+  "password",
+  "privatekey",
+  "prompt",
+  "promptbody",
+  "prompttext",
+  "rawcommand",
+  "rawcommandoutput",
+  "rawlog",
+  "rawlogs",
+  "rawoutput",
+  "rawpayload",
+  "rawprompt",
+  "secret",
+  "secretvalue",
+  "source",
+  "sourcebody",
+  "sourcecode",
+  "sourcecontent",
+  "sourcetext",
+  "stderr",
+  "stdout",
+  "token",
+  "transcript",
+  "transcriptbody",
+  "transcripttext"
+]);
+// 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";
 var RESERVED_OKF_FILENAMES = new Set(["index.md", "log.md"]);
@@ -192,19 +263,19 @@ var BEHAVIOR_CHANGE_KINDS = new Set([
   "repo-asset-suggestion"
 ]);
 function resolveOkfKnowledgePaths(homeDir) {
-  const paths = resolveEvoDevPaths(homeDir);
+  const paths2 = resolveEvoDevPaths(homeDir);
   return {
-    knowledgeDir: paths.knowledgeDir,
-    okfDir: join(paths.knowledgeDir, "okf"),
-    indexesDir: join(paths.knowledgeDir, "indexes"),
-    tmpDir: join(paths.knowledgeDir, "tmp")
+    knowledgeDir: paths2.knowledgeDir,
+    okfDir: join(paths2.knowledgeDir, "okf"),
+    indexesDir: join(paths2.knowledgeDir, "indexes"),
+    tmpDir: join(paths2.knowledgeDir, "tmp")
   };
 }
 async function ensureOkfKnowledgeBase(homeDir) {
-  const paths = resolveOkfKnowledgePaths(homeDir);
-  await ensureLocalKnowledgeGitRepository(paths.knowledgeDir);
-  await mkdir(paths.indexesDir, { recursive: true });
-  await mkdir(paths.tmpDir, { recursive: true });
+  const paths2 = resolveOkfKnowledgePaths(homeDir);
+  await ensureLocalKnowledgeGitRepository(paths2.knowledgeDir);
+  await mkdir(paths2.indexesDir, { recursive: true });
+  await mkdir(paths2.tmpDir, { recursive: true });
   const directories = [
     {
       path: "",
@@ -234,13 +305,13 @@ async function ensureOkfKnowledgeBase(homeDir) {
     { path: "references", title: "References", description: "Cited references." }
   ];
   for (const directory of directories) {
-    await ensureOkfDirectory(paths.okfDir, directory.path, directory.title, directory.description);
+    await ensureOkfDirectory(paths2.okfDir, directory.path, directory.title, directory.description);
   }
   await rebuildOkfKnowledgeIndexes({ homeDir });
 }
 async function rebuildOkfKnowledgeIndexes(input) {
-  const paths = resolveOkfKnowledgePaths(input.homeDir);
-  await mkdir(paths.indexesDir, { recursive: true });
+  const paths2 = resolveOkfKnowledgePaths(input.homeDir);
+  await mkdir(paths2.indexesDir, { recursive: true });
   const concepts = (await listOkfKnowledgeConcepts({ homeDir: input.homeDir })).filter(isActiveOkfConcept);
   const conceptSummaries = concepts.map((concept) => ({
     id: concept.id,
@@ -257,34 +328,34 @@ async function rebuildOkfKnowledgeIndexes(input) {
     pathScopes: concept.pathScopes
   }));
   const pathsWritten = [
-    join(paths.indexesDir, "index.json"),
-    join(paths.indexesDir, "concepts.json"),
-    join(paths.indexesDir, "repos.json"),
-    join(paths.indexesDir, "roles.json"),
-    join(paths.indexesDir, "workflows.json")
+    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")
   ];
-  await writeJson(pathsWritten[0], {
+  await writeJson2(pathsWritten[0], {
     schemaVersion: 1,
     kind: "okf-knowledge-index",
     conceptCount: concepts.length,
     updatedAt: new Date().toISOString()
   }, { overwrite: true });
-  await writeJson(pathsWritten[1], {
+  await writeJson2(pathsWritten[1], {
     schemaVersion: 1,
     kind: "okf-concepts-index",
     concepts: conceptSummaries
   }, { overwrite: true });
-  await writeJson(pathsWritten[2], {
+  await writeJson2(pathsWritten[2], {
     schemaVersion: 1,
     kind: "okf-repos-index",
     repos: groupConceptsByTag(concepts, "repoTags")
   }, { overwrite: true });
-  await writeJson(pathsWritten[3], {
+  await writeJson2(pathsWritten[3], {
     schemaVersion: 1,
     kind: "okf-roles-index",
     roles: groupConceptsByTag(concepts, "roleTags")
   }, { overwrite: true });
-  await writeJson(pathsWritten[4], {
+  await writeJson2(pathsWritten[4], {
     schemaVersion: 1,
     kind: "okf-workflows-index",
     workflows: groupConceptsByTag(concepts, "workflowTags")
@@ -293,7 +364,7 @@ async function rebuildOkfKnowledgeIndexes(input) {
 }
 async function listOkfKnowledgeConcepts(input) {
   const okfDir = resolveOkfKnowledgePaths(input.homeDir).okfDir;
-  if (!await pathExists(okfDir))
+  if (!await pathExists2(okfDir))
     return [];
   const files = await listMarkdownFiles(okfDir);
   const concepts = [];
@@ -310,7 +381,7 @@ async function listOkfKnowledgeConcepts(input) {
 async function ensureLocalKnowledgeGitRepository(knowledgeDir) {
   await mkdir(knowledgeDir, { recursive: true });
   const gitDir = join(knowledgeDir, ".git");
-  if (await pathExists(gitDir))
+  if (await pathExists2(gitDir))
     return;
   await mkdir(join(gitDir, "objects", "info"), { recursive: true });
   await mkdir(join(gitDir, "objects", "pack"), { recursive: true });
@@ -336,7 +407,7 @@ async function ensureLocalKnowledgeGitRepository(knowledgeDir) {
 `));
 }
 async function writeTextIfMissing(path, value) {
-  if (await pathExists(path))
+  if (await pathExists2(path))
     return;
   await mkdir(dirname(path), { recursive: true });
   await writeFile(path, value, { encoding: "utf8", flag: "wx" });
@@ -349,7 +420,7 @@ async function ensureOkfDirectory(okfDir, relativeDir, title, description) {
   await mkdir(dir, { recursive: true });
   const isRoot = dir === okfDir;
   const indexPath = join(dir, "index.md");
-  if (!await pathExists(indexPath)) {
+  if (!await pathExists2(indexPath)) {
     await writeFile(indexPath, isRoot ? [
       "---",
       `okf_version: ${yamlString("0.1")}`,
@@ -366,7 +437,7 @@ async function ensureOkfDirectory(okfDir, relativeDir, title, description) {
 `), "utf8");
   }
   const logPath = join(dir, "log.md");
-  if (!await pathExists(logPath)) {
+  if (!await pathExists2(logPath)) {
     await writeFile(logPath, [
       "# Directory Update Log",
       "",
@@ -473,13 +544,13 @@ function isLifecycleDateDue(value, now) {
 }
 function createDefaultOkfLifecycle(input) {
   const createdAt = normalizeIsoDateString(input.createdAt) ?? "1970-01-01T00:00:00.000Z";
-  const policy = resolveOkfLifecyclePolicy(input);
+  const policy2 = resolveOkfLifecyclePolicy(input);
   return {
     status: lifecycleStatusFromReviewState(input.reviewState),
     createdAt,
     lastVerifiedAt: createdAt,
-    reviewAfter: addDaysIso(createdAt, policy.reviewAfterDays),
-    staleAfter: addDaysIso(createdAt, policy.staleAfterDays),
+    reviewAfter: addDaysIso(createdAt, policy2.reviewAfterDays),
+    staleAfter: addDaysIso(createdAt, policy2.staleAfterDays),
     supersedes: [],
     supersededBy: null,
     revokedAt: null,
@@ -537,10 +608,10 @@ function isOkfLifecycleStatus(value) {
 function normalizeIsoDateString(value) {
   if (value === undefined || value === null || value === "" || value === "null")
     return null;
-  const time = Date.parse(value);
-  if (!Number.isFinite(time))
+  const time2 = Date.parse(value);
+  if (!Number.isFinite(time2))
     return null;
-  return new Date(time).toISOString();
+  return new Date(time2).toISOString();
 }
 function addDaysIso(value, days) {
   const date = new Date(value);
@@ -641,7 +712,7 @@ function parseYamlValue(value) {
   return trimmed.replace(/^['"]|['"]$/gu, "");
 }
 async function listMarkdownFiles(root) {
-  if (!await pathExists(root))
+  if (!await pathExists2(root))
     return [];
   const entries = await readdir(root, { withFileTypes: true });
   const files = [];
@@ -694,13 +765,13 @@ function escapeRegExp(value) {
 function todayIsoDate() {
   return new Date().toISOString().slice(0, 10);
 }
-async function writeJson(path, value, options = {}) {
+async function writeJson2(path, value, options = {}) {
   await mkdir(dirname(path), { recursive: true });
   const flag = options.overwrite === true ? "w" : "wx";
   await writeFile(path, `${JSON.stringify(value, null, 2)}
 `, { encoding: "utf8", flag });
 }
-async function pathExists(path) {
+async function pathExists2(path) {
   try {
     await stat(path);
     return true;
@@ -711,43 +782,6 @@ async function pathExists(path) {
   }
 }
 
-// packages/core/src/evolution/index.ts
-var PROCESS_LOCK_STALE_MS = 5 * 60 * 1000;
-var FORBIDDEN_RAW_KEYS = new Set([
-  "commandhistory",
-  "commandoutput",
-  "credential",
-  "credentials",
-  "env",
-  "fullsource",
-  "memorybody",
-  "password",
-  "privatekey",
-  "prompt",
-  "promptbody",
-  "prompttext",
-  "rawcommand",
-  "rawcommandoutput",
-  "rawlog",
-  "rawlogs",
-  "rawoutput",
-  "rawpayload",
-  "rawprompt",
-  "secret",
-  "secretvalue",
-  "source",
-  "sourcebody",
-  "sourcecode",
-  "sourcecontent",
-  "sourcetext",
-  "stderr",
-  "stdout",
-  "token",
-  "transcript",
-  "transcriptbody",
-  "transcripttext"
-]);
-
 // packages/core/src/task/index.ts
 var FORBIDDEN_TASK_WRITE_SEGMENTS = new Set([".claude", ".codex"]);
 var FORBIDDEN_PROJECT_ASSET_SEGMENTS = new Set(["packages", "src"]);
@@ -964,10 +998,10 @@ function parseHookSettings(value) {
   if (!isRecord(value))
     throw new Error("Invalid hooks settings; expected object.");
   const observability = isRecord(value.observability) ? value.observability : undefined;
-  optionalBoolean(observability?.metadataOnly, defaults.observability.metadataOnly, "hooks.observability.metadataOnly");
-  optionalBoolean(observability?.rawPayloadStorage, defaults.observability.rawPayloadStorage, "hooks.observability.rawPayloadStorage");
+  optionalBoolean2(observability?.metadataOnly, defaults.observability.metadataOnly, "hooks.observability.metadataOnly");
+  optionalBoolean2(observability?.rawPayloadStorage, defaults.observability.rawPayloadStorage, "hooks.observability.rawPayloadStorage");
   return {
-    enabled: optionalBoolean(value.enabled, defaults.enabled, "hooks.enabled"),
+    enabled: optionalBoolean2(value.enabled, defaults.enabled, "hooks.enabled"),
     targets: {
       claude: parseHookTargetSettings(value.targets, defaults.targets.claude, "claude"),
       codex: parseHookTargetSettings(value.targets, defaults.targets.codex, "codex")
@@ -975,7 +1009,7 @@ function parseHookSettings(value) {
     observability: {
       metadataOnly: true,
       rawPayloadStorage: false,
-      appendEvents: optionalBoolean(observability?.appendEvents, defaults.observability.appendEvents, "hooks.observability.appendEvents")
+      appendEvents: optionalBoolean2(observability?.appendEvents, defaults.observability.appendEvents, "hooks.observability.appendEvents")
     },
     learning: {
       emitCandidates: false,
@@ -989,14 +1023,14 @@ function parseHookTargetSettings(value, defaults, target) {
   const events = isRecord(targetSettings.events) ? targetSettings.events : {};
   const parsedEvents = { ...defaults.events };
   for (const eventType of CANONICAL_HOOK_EVENT_TYPES) {
-    parsedEvents[eventType] = optionalBoolean(events[eventType], defaults.events[eventType], `hooks.targets.${target}.events.${eventType}`);
+    parsedEvents[eventType] = optionalBoolean2(events[eventType], defaults.events[eventType], `hooks.targets.${target}.events.${eventType}`);
   }
   return {
-    enabled: optionalBoolean(targetSettings.enabled, defaults.enabled, `hooks.targets.${target}.enabled`),
+    enabled: optionalBoolean2(targetSettings.enabled, defaults.enabled, `hooks.targets.${target}.enabled`),
     events: parsedEvents
   };
 }
-function optionalBoolean(value, fallback, path) {
+function optionalBoolean2(value, fallback, path) {
   if (value === undefined)
     return fallback;
   if (typeof value !== "boolean")
@@ -1054,7 +1088,8 @@ function createDefaultMemorySettings() {
     autoAccept: true,
     runtimeInjection: true,
     staleReview: true,
-    lexicalIndex: true
+    lexicalIndex: true,
+    sessionMemory: createDefaultSessionMemoryPolicy()
   };
 }
 function mergeSettings(existing, defaults = createDefaultSettings()) {
@@ -1102,11 +1137,11 @@ function mergeSettings(existing, defaults = createDefaultSettings()) {
   return parseSettings(merged);
 }
 async function readRuntimeInjectionSettings(homeDir) {
-  const paths = resolveEvoDevPaths(homeDir);
+  const paths2 = resolveEvoDevPaths(homeDir);
   try {
-    return parseSettings(JSON.parse(await readFile2(paths.settingsPath, "utf8"))).memory;
+    return parseSettings(JSON.parse(await readFile2(paths2.settingsPath, "utf8"))).memory;
   } catch (error) {
-    if (isNotFoundError(error))
+    if (isNotFoundError2(error))
       return createDefaultMemorySettings();
     throw error;
   }
@@ -1154,7 +1189,8 @@ function parseMemorySettings(value, path) {
     autoAccept: input.autoAccept === undefined ? defaults.autoAccept : expectBoolean(input.autoAccept, `${path}.autoAccept`),
     runtimeInjection: input.runtimeInjection === undefined ? defaults.runtimeInjection : expectBoolean(input.runtimeInjection, `${path}.runtimeInjection`),
     staleReview: input.staleReview === undefined ? defaults.staleReview : expectBoolean(input.staleReview, `${path}.staleReview`),
-    lexicalIndex: input.lexicalIndex === undefined ? defaults.lexicalIndex : expectBoolean(input.lexicalIndex, `${path}.lexicalIndex`)
+    lexicalIndex: input.lexicalIndex === undefined ? defaults.lexicalIndex : expectBoolean(input.lexicalIndex, `${path}.lexicalIndex`),
+    sessionMemory: parseSessionMemoryPolicy(isPlainRecord(input.sessionMemory) ? input.sessionMemory : defaults.sessionMemory)
   };
 }
 function parseTeamRuntimeSettings(value, path) {
@@ -1198,7 +1234,10 @@ function expectRecord2(value, path) {
   }
   return value;
 }
-function isNotFoundError(error) {
+function isPlainRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNotFoundError2(error) {
   return error instanceof Error && "code" in error && error.code === "ENOENT";
 }
 function expectString2(value, path) {
@@ -1303,50 +1342,50 @@ function expectNonNegativeInteger(value, path) {
 import { mkdir as mkdir2, readFile as readFile3, writeFile as writeFile2 } from "node:fs/promises";
 import { dirname as dirname2 } from "node:path";
 function createCoreConfigStore(homeDir) {
-  const paths = resolveEvoDevPaths(homeDir);
+  const paths2 = resolveEvoDevPaths(homeDir);
   return {
-    paths,
+    paths: paths2,
     async ensureBaseDirs() {
-      await mkdir2(paths.stateDir, { recursive: true });
-      await mkdir2(paths.logsDir, { recursive: true });
-      await mkdir2(paths.knowledgeDir, { recursive: true });
-      await mkdir2(paths.evosCasesDir, { recursive: true });
-      await mkdir2(paths.roleAgentsDir, { recursive: true });
-      await mkdir2(paths.teamsDir, { recursive: true });
-      await mkdir2(paths.runsDir, { recursive: true });
+      await mkdir2(paths2.stateDir, { recursive: true });
+      await mkdir2(paths2.logsDir, { recursive: true });
+      await mkdir2(paths2.knowledgeDir, { recursive: true });
+      await mkdir2(paths2.evosCasesDir, { recursive: true });
+      await mkdir2(paths2.roleAgentsDir, { recursive: true });
+      await mkdir2(paths2.teamsDir, { recursive: true });
+      await mkdir2(paths2.runsDir, { recursive: true });
     },
     async ensureKnowledgeBase() {
-      await ensureKnowledgeBaseFiles(paths);
+      await ensureKnowledgeBaseFiles(paths2);
     },
     async readSettings() {
-      return readJsonFile(paths.settingsPath, parseSettings);
+      return readJsonFile(paths2.settingsPath, parseSettings);
     },
     async writeSettings(settings) {
-      await writeJsonFile(paths.settingsPath, parseSettings(settings));
+      await writeJsonFile2(paths2.settingsPath, parseSettings(settings));
     },
     async mergeAndWriteSettings(input) {
-      const current = await readJsonFileOrDefault(paths.settingsPath, parseSettings, createDefaultSettings());
+      const current = await readJsonFileOrDefault(paths2.settingsPath, parseSettings, createDefaultSettings());
       const merged = mergeSettings(input, current);
-      await writeJsonFile(paths.settingsPath, merged);
+      await writeJsonFile2(paths2.settingsPath, merged);
       return merged;
     },
     async readRegistry() {
-      return readJsonFile(paths.registryPath, parseRegistry);
+      return readJsonFile(paths2.registryPath, parseRegistry);
     },
     async writeRegistry(registry) {
-      await writeJsonFile(paths.registryPath, parseRegistry(registry));
+      await writeJsonFile2(paths2.registryPath, parseRegistry(registry));
     },
     async readInstallState() {
-      return readJsonFile(paths.installStatePath, parseInstallState);
+      return readJsonFile(paths2.installStatePath, parseInstallState);
     },
     async writeInstallState(state) {
-      await writeJsonFile(paths.installStatePath, parseInstallState(state));
+      await writeJsonFile2(paths2.installStatePath, parseInstallState(state));
     },
     async readSyncState() {
-      return readJsonFile(paths.syncStatePath, parseSyncState);
+      return readJsonFile(paths2.syncStatePath, parseSyncState);
     },
     async writeSyncState(state) {
-      await writeJsonFile(paths.syncStatePath, parseSyncState(state));
+      await writeJsonFile2(paths2.syncStatePath, parseSyncState(state));
     }
   };
 }
@@ -1360,11 +1399,11 @@ async function initializeCoreConfig(homeDir) {
   await writeIfMissing(store.paths.syncStatePath, createDefaultSyncState());
   return store;
 }
-async function ensureKnowledgeBaseFiles(paths) {
-  await mkdir2(paths.knowledgeDir, { recursive: true });
-  await mkdir2(paths.evosCasesDir, { recursive: true });
-  await ensureOkfKnowledgeBase(paths.homeDir);
-  await writeTextIfMissing2(`${paths.knowledgeDir}/README.md`, [
+async function ensureKnowledgeBaseFiles(paths2) {
+  await mkdir2(paths2.knowledgeDir, { recursive: true });
+  await mkdir2(paths2.evosCasesDir, { recursive: true });
+  await ensureOkfKnowledgeBase(paths2.homeDir);
+  await writeTextIfMissing2(`${paths2.knowledgeDir}/README.md`, [
     "# EvoDev Knowledge",
     "",
     "Local-private knowledge base for user-accepted facts, decisions, architecture notes, and reusable domain context.",
@@ -1373,13 +1412,13 @@ async function ensureKnowledgeBaseFiles(paths) {
     ""
   ].join(`
 `));
-  await writeIndexIfMissingOrMigrate(paths.knowledgeIndexPath, "knowledge-index", {
+  await writeIndexIfMissingOrMigrate(paths2.knowledgeIndexPath, "knowledge-index", {
     version: 1,
     kind: "knowledge-index",
     roleTags: [],
     entries: []
   });
-  await writeTextIfMissing2(`${paths.evosDir}/README.md`, [
+  await writeTextIfMissing2(`${paths2.evosDir}/README.md`, [
     "# EvoDev Evos",
     "",
     "Local-private evolution case library for reviewed improvement cases and reusable process changes.",
@@ -1388,20 +1427,20 @@ async function ensureKnowledgeBaseFiles(paths) {
     ""
   ].join(`
 `));
-  await writeTextIfMissing2(`${paths.evosCasesDir}/README.md`, [
+  await writeTextIfMissing2(`${paths2.evosCasesDir}/README.md`, [
     "# Evolution Cases",
     "",
     "Store one reviewed evolution case per file. Do not store raw prompts, source dumps, secrets, transcripts, or raw command output here.",
     ""
   ].join(`
 `));
-  await writeIndexIfMissingOrMigrate(paths.evosIndexPath, "evos-index", {
+  await writeIndexIfMissingOrMigrate(paths2.evosIndexPath, "evos-index", {
     version: 1,
     kind: "evos-index",
     roleTags: [],
     cases: []
   });
-  await writeTextIfMissing2(`${paths.roleAgentsDir}/README.md`, [
+  await writeTextIfMissing2(`${paths2.roleAgentsDir}/README.md`, [
     "# Role Agents",
     "",
     "Local-private role agent registry for EvoDev-managed agent roles and user-reviewed role extensions.",
@@ -1410,13 +1449,13 @@ async function ensureKnowledgeBaseFiles(paths) {
     ""
   ].join(`
 `));
-  await writeIndexIfMissingOrMigrate(paths.roleAgentsIndexPath, "role-agent-index", {
+  await writeIndexIfMissingOrMigrate(paths2.roleAgentsIndexPath, "role-agent-index", {
     version: 1,
     kind: "role-agent-index",
     roles: [],
     projectExtensions: []
   });
-  await writeTextIfMissing2(`${paths.teamsDir}/README.md`, [
+  await writeTextIfMissing2(`${paths2.teamsDir}/README.md`, [
     "# Agent Teams",
     "",
     "Local-private EvoHub team registry for reviewed role-agent team definitions.",
@@ -1425,7 +1464,7 @@ async function ensureKnowledgeBaseFiles(paths) {
     ""
   ].join(`
 `));
-  await writeIndexIfMissingOrMigrate(paths.teamsIndexPath, "agent-team-index", {
+  await writeIndexIfMissingOrMigrate(paths2.teamsIndexPath, "agent-team-index", {
     version: 1,
     kind: "agent-team-index",
     teams: []
@@ -1468,7 +1507,7 @@ async function writeIfMissing(filePath, value) {
     await readFile3(filePath, "utf8");
   } catch (error) {
     if (isNodeError(error) && error.code === "ENOENT") {
-      await writeJsonFile(filePath, value);
+      await writeJsonFile2(filePath, value);
       return;
     }
     throw new EvoDevConfigError(`Cannot inspect config file (${describeFileError(error)})`, filePath);
@@ -1480,7 +1519,7 @@ async function writeIndexIfMissingOrMigrate(filePath, kind, defaults) {
     raw = await readFile3(filePath, "utf8");
   } catch (error) {
     if (isNodeError(error) && error.code === "ENOENT") {
-      await writeJsonFile(filePath, defaults);
+      await writeJsonFile2(filePath, defaults);
       return;
     }
     throw new EvoDevConfigError(`Cannot inspect config file (${describeFileError(error)})`, filePath);
@@ -1496,7 +1535,7 @@ async function writeIndexIfMissingOrMigrate(filePath, kind, defaults) {
   const migrated = { ...defaults, ...existing };
   if (Object.keys(defaults).every((key) => (key in existing)))
     return;
-  await writeJsonFile(filePath, migrated);
+  await writeJsonFile2(filePath, migrated);
 }
 async function writeTextIfMissing2(filePath, value) {
   try {
@@ -1510,7 +1549,7 @@ async function writeTextIfMissing2(filePath, value) {
     throw new EvoDevConfigError(`Cannot inspect config file (${describeFileError(error)})`, filePath);
   }
 }
-async function writeJsonFile(filePath, value) {
+async function writeJsonFile2(filePath, value) {
   await mkdir2(dirname2(filePath), { recursive: true });
   await writeFile2(filePath, `${JSON.stringify(value, null, 2)}
 `, "utf8");