@evo-dev/core 0.0.1-alpha.1 → 0.0.1-alpha.11

package/src/config/settings.ts

@@ -1,5 +1,12 @@
+import { readFile } from "node:fs/promises";
+import {
+  type SessionMemoryPolicySnapshot,
+  createDefaultSessionMemoryPolicy,
+  parseSessionMemoryPolicy,
+} from "../evolution/evidence/session-memory/index.ts";
 import { type HookSettings, createDefaultHookSettings, parseHookSettings } from "../hooks/index.ts";
 import { EvoDevConfigError, describeType } from "./errors.ts";
+import { resolveEvoDevPaths } from "./paths.ts";
 
 export interface PluginSettings {
   enabled: boolean;
@@ -7,6 +14,22 @@ export interface PluginSettings {
   autoSyncAgents?: boolean;
 }
 
+export interface MemorySettings {
+  autoAccept: boolean;
+  runtimeInjection: boolean;
+  staleReview: boolean;
+  lexicalIndex: boolean;
+  sessionMemory: SessionMemoryPolicySnapshot;
+}
+
+export interface EvolutionSettings {
+  automation: {
+    knowledge: boolean;
+    semanticKnowledge: boolean;
+    recommendations: boolean;
+  };
+}
+
 export interface EvoDevSettings {
   version: 1;
   platform: {
@@ -29,6 +52,8 @@ export interface EvoDevSettings {
   };
   hooks: HookSettings;
   teamRuntime: TeamRuntimeSettings;
+  memory: MemorySettings;
+  evolution: EvolutionSettings;
 }
 
 export type SettingsInput = Partial<{
@@ -45,6 +70,10 @@ export type SettingsInput = Partial<{
   doctor: Partial<EvoDevSettings["doctor"]>;
   hooks: unknown;
   teamRuntime: Partial<TeamRuntimeSettings>;
+  memory: Partial<MemorySettings>;
+  evolution: Partial<{
+    automation: Partial<EvolutionSettings["automation"]>;
+  }>;
 }>;
 
 export interface TeamRuntimeSettings {
@@ -52,6 +81,7 @@ export interface TeamRuntimeSettings {
   defaultModel: string | null;
   defaultThinkingLevel: string | null;
   recordTranscript: boolean;
+  displayMode: "normal" | "development";
 }
 
 export function createDefaultSettings(os: string = process.platform): EvoDevSettings {
@@ -83,6 +113,8 @@ export function createDefaultSettings(os: string = process.platform): EvoDevSett
     },
     hooks: createDefaultHookSettings(),
     teamRuntime: createDefaultTeamRuntimeSettings(),
+    memory: createDefaultMemorySettings(),
+    evolution: createDefaultEvolutionSettings(),
   };
 }
 
@@ -92,6 +124,27 @@ export function createDefaultTeamRuntimeSettings(): TeamRuntimeSettings {
     defaultModel: null,
     defaultThinkingLevel: null,
     recordTranscript: false,
+    displayMode: "normal",
+  };
+}
+
+export function createDefaultMemorySettings(): MemorySettings {
+  return {
+    autoAccept: true,
+    runtimeInjection: true,
+    staleReview: true,
+    lexicalIndex: true,
+    sessionMemory: createDefaultSessionMemoryPolicy(),
+  };
+}
+
+export function createDefaultEvolutionSettings(): EvolutionSettings {
+  return {
+    automation: {
+      knowledge: true,
+      semanticKnowledge: false,
+      recommendations: false,
+    },
   };
 }
 
@@ -135,11 +188,33 @@ export function mergeSettings(
       ...defaults.teamRuntime,
       ...existing.teamRuntime,
     },
+    memory: {
+      ...defaults.memory,
+      ...existing.memory,
+    },
+    evolution: {
+      ...defaults.evolution,
+      ...existing.evolution,
+      automation: {
+        ...defaults.evolution.automation,
+        ...existing.evolution?.automation,
+      },
+    },
   };
 
   return parseSettings(merged);
 }
 
+export async function readRuntimeInjectionSettings(homeDir?: string): Promise<MemorySettings> {
+  const paths = resolveEvoDevPaths(homeDir);
+  try {
+    return parseSettings(JSON.parse(await readFile(paths.settingsPath, "utf8"))).memory;
+  } catch (error) {
+    if (isNotFoundError(error)) return createDefaultMemorySettings();
+    throw error;
+  }
+}
+
 export function parseSettings(value: unknown): EvoDevSettings {
   const root = expectRecord(value, "settings");
   const version = root.version;
@@ -184,11 +259,64 @@ export function parseSettings(value: unknown): EvoDevSettings {
       root.teamRuntime ?? createDefaultTeamRuntimeSettings(),
       "settings.teamRuntime",
     ),
+    memory: parseMemorySettings(root.memory ?? createDefaultMemorySettings(), "settings.memory"),
+    evolution: parseEvolutionSettings(
+      root.evolution ?? createDefaultEvolutionSettings(),
+      "settings.evolution",
+    ),
   };
 
   return parsed;
 }
 
+function parseEvolutionSettings(value: unknown, path: string): EvolutionSettings {
+  const input = expectRecord(value, path);
+  const defaults = createDefaultEvolutionSettings();
+  const automation = expectRecord(input.automation ?? defaults.automation, `${path}.automation`);
+  return {
+    automation: {
+      knowledge:
+        automation.knowledge === undefined
+          ? defaults.automation.knowledge
+          : expectBoolean(automation.knowledge, `${path}.automation.knowledge`),
+      semanticKnowledge:
+        automation.semanticKnowledge === undefined
+          ? defaults.automation.semanticKnowledge
+          : expectBoolean(automation.semanticKnowledge, `${path}.automation.semanticKnowledge`),
+      recommendations:
+        automation.recommendations === undefined
+          ? defaults.automation.recommendations
+          : expectBoolean(automation.recommendations, `${path}.automation.recommendations`),
+    },
+  };
+}
+
+function parseMemorySettings(value: unknown, path: string): MemorySettings {
+  const input = expectRecord(value, path);
+  const defaults = createDefaultMemorySettings();
+  return {
+    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`),
+    sessionMemory: parseSessionMemoryPolicy(
+      isPlainRecord(input.sessionMemory) ? input.sessionMemory : defaults.sessionMemory,
+    ),
+  };
+}
+
 function parseTeamRuntimeSettings(value: unknown, path: string): TeamRuntimeSettings {
   const input = expectRecord(value, path);
   const defaults = createDefaultTeamRuntimeSettings();
@@ -211,9 +339,20 @@ function parseTeamRuntimeSettings(value: unknown, path: string): TeamRuntimeSett
       input.recordTranscript === undefined
         ? defaults.recordTranscript
         : expectBoolean(input.recordTranscript, `${path}.recordTranscript`),
+    displayMode: parseTeamRuntimeDisplayMode(input.displayMode, defaults.displayMode, path),
   };
 }
 
+function parseTeamRuntimeDisplayMode(
+  value: unknown,
+  fallback: TeamRuntimeSettings["displayMode"],
+  path: string,
+): TeamRuntimeSettings["displayMode"] {
+  if (value === undefined) return fallback;
+  if (value === "normal" || value === "development") return value;
+  throw new EvoDevConfigError(`Invalid ${path}.displayMode; expected normal or development`);
+}
+
 function parsePluginSettings(value: unknown, path: string): PluginSettings {
   const input = expectRecord(value, path);
   const parsed: PluginSettings = {
@@ -239,6 +378,16 @@ function expectRecord(value: unknown, path: string): Record<string, unknown> {
   return value as Record<string, unknown>;
 }
 
+function isPlainRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function isNotFoundError(error: unknown): boolean {
+  return (
+    error instanceof Error && "code" in error && (error as NodeJS.ErrnoException).code === "ENOENT"
+  );
+}
+
 function expectString(value: unknown, path: string): string {
   if (typeof value !== "string" || value.length === 0) {
     throw new EvoDevConfigError(`Invalid ${path}; expected non-empty string`);

package/src/config/store.ts

@@ -1,5 +1,6 @@
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { dirname } from "node:path";
+import { ensureOkfKnowledgeBase } from "../evolution/knowledge/index.ts";
 import { EvoDevConfigError } from "./errors.ts";
 import { type EvoDevPaths, resolveEvoDevPaths } from "./paths.ts";
 import { type EvoDevRegistry, createDefaultRegistry, parseRegistry } from "./registry.ts";
@@ -102,6 +103,7 @@ export async function initializeCoreConfig(homeDir?: string): Promise<CoreConfig
 export async function ensureKnowledgeBaseFiles(paths: EvoDevPaths): Promise<void> {
   await mkdir(paths.knowledgeDir, { recursive: true });
   await mkdir(paths.evosCasesDir, { recursive: true });
+  await ensureOkfKnowledgeBase(paths.homeDir);
   await writeTextIfMissing(
     `${paths.knowledgeDir}/README.md`,
     [

package/src/daemon/index.ts

@@ -2,16 +2,23 @@ import { randomBytes } from "node:crypto";
 import { mkdir, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
 import { type IncomingMessage, createServer } from "node:http";
 import { dirname, join } from "node:path";
-import { listEvolutionTriggers, processEvolutionTriggers } from "../evolution/index.ts";
+import { listEvolutionTriggers, processEvolutionTriggers } from "../evolution/control/index.ts";
 import { listObservabilityEvents } from "../observability/index.ts";
 import {
   type TeamRuntimeAdapter,
+  isActiveTeamAgentStatus,
+  isIdleTeamAgentStatus,
+  isMidTurnTeamAgentStatus,
   listTeamRuns,
+  markTeamMessagesDelivered,
+  readPendingTeamMessagesForRole,
   reconcileTeamRun,
   resumeTeamRun,
+  schedulePendingTeamMessageDelivery,
   sendTeamMessage,
   spawnTeamRole,
   stopTeamRole,
+  updateTeamAgentHookState,
 } from "../team/index.ts";
 
 export interface DaemonPaths {
@@ -182,12 +189,42 @@ export async function handleDaemonRequest(
     const removed = await cleanupDaemonState(input.homeDir, input.token ?? "");
     return ok({ stopped: true, removed }, warnings);
   }
-  if (input.path === "/teams/send" && input.method === "POST") {
+  if (
+    (input.path === "/team/message/enqueue" || input.path === "/teams/send") &&
+    input.method === "POST"
+  ) {
     return dashboardMutation(
       await sendDashboardTeamMessage(input.homeDir, input.body, input.runtimeAdapter),
       warnings,
     );
   }
+  if (input.path === "/team/agent/state" && input.method === "POST") {
+    return dashboardMutation(
+      await updateDashboardTeamAgentState(input.homeDir, input.body),
+      warnings,
+    );
+  }
+  if (input.path === "/team/message/claim" && input.method === "POST") {
+    return ok(await claimDashboardTeamMessages(input.homeDir, input.body), warnings);
+  }
+  if (input.path === "/team/message/delivered" && input.method === "POST") {
+    return dashboardMutation(
+      await markDashboardTeamMessagesDelivered(input.homeDir, input.body),
+      warnings,
+    );
+  }
+  if (
+    (input.path === "/team/reconcile" || input.path === "/teams/reconcile") &&
+    input.method === "POST"
+  ) {
+    await schedulePendingTeamMessageDelivery({
+      homeDir: input.homeDir,
+      runtimeAdapter: input.runtimeAdapter,
+    }).catch((error) =>
+      warnings.push(`Team delivery scheduling unavailable: ${describeError(error)}`),
+    );
+    return ok(await collectTeamStatus(input.homeDir, warnings, input.runtimeAdapter), warnings);
+  }
   if (input.path === "/teams/spawn" && input.method === "POST") {
     return dashboardMutation(
       await spawnDashboardTeamRole(input.homeDir, input.body, input.runtimeAdapter),
@@ -206,9 +243,6 @@ export async function handleDaemonRequest(
       warnings,
     );
   }
-  if (input.path === "/teams/reconcile" && input.method === "POST") {
-    return ok(await collectTeamStatus(input.homeDir, warnings, input.runtimeAdapter), warnings);
-  }
   if (input.path === "/evolution/process" && input.method === "POST") {
     return dashboardMutation(
       await processDashboardEvolutionTriggers(input.homeDir, input.body),
@@ -217,8 +251,6 @@ export async function handleDaemonRequest(
   }
   if (input.method !== "GET") return notFound(warnings);
 
-  if (input.path === "/tasks")
-    return ok(await collectTaskSummaries(input.homeDir, warnings), warnings);
   if (input.path === "/observability/events")
     return ok(await collectObservabilitySummaries(input.homeDir, warnings), warnings);
   if (input.path === "/memory/candidates")
@@ -373,33 +405,6 @@ function isAllowedLocalOrigin(origin: string | null): boolean {
   }
 }
 
-async function collectTaskSummaries(homeDir: string, warnings: string[]): Promise<unknown[]> {
-  const root = join(homeDir, ".evodev", "STATE", "tasks");
-  if (!(await pathExists(root))) {
-    warnings.push("Task store not found; returning empty tasks.");
-    return [];
-  }
-  const contracts = await collectNamedFiles(root, "contract.json");
-  const summaries: unknown[] = [];
-  for (const file of contracts) {
-    try {
-      const contract = JSON.parse(await readFile(file, "utf8"));
-      summaries.push(
-        sanitizeMetadata({
-          taskId: contract.taskId,
-          status: contract.status,
-          mode: contract.route?.mode ?? null,
-          workflowId: contract.route?.workflowId ?? null,
-          verificationStatus: contract.verification?.status ?? null,
-        }),
-      );
-    } catch {
-      warnings.push(`Skipped unreadable task contract: ${file}`);
-    }
-  }
-  return summaries;
-}
-
 async function collectObservabilitySummaries(
   homeDir: string,
   warnings: string[],
@@ -541,10 +546,9 @@ async function collectTeamStatus(
         thinkingLevel: agent.thinkingLevel,
         status: agent.status,
         paneId: agent.tmux.paneId,
-        canReceiveMessages:
-          agent.status === "running" ||
-          agent.status === "recovering" ||
-          agent.status === "recreated",
+        canReceiveMessages: isActiveTeamAgentStatus(agent.status),
+        isIdle: isIdleTeamAgentStatus(agent.status),
+        isMidTurn: isMidTurnTeamAgentStatus(agent.status),
         nativeSessionRecorded: agent.nativeSession.sessionId !== null,
         updatedAt: agent.updatedAt,
       })),
@@ -552,7 +556,8 @@ async function collectTeamStatus(
       notifications: status.notifications.map((notification) => ({
         ok: notification.ok,
         error: notification.error ?? null,
-        deliveredTo: notification.deliveredTo ?? null,
+        delivery: notification.delivery ?? null,
+        queuedFor: notification.queuedFor ?? null,
       })),
     }) as DaemonTeamStatusSummary;
   } catch (error) {
@@ -577,6 +582,61 @@ async function sendDashboardTeamMessage(
   });
 }
 
+async function updateDashboardTeamAgentState(homeDir: string, body: unknown): Promise<unknown> {
+  const input = expectRequestBody(body);
+  const result = await updateTeamAgentHookState({
+    homeDir,
+    runId: expectBodyString(input, "runId"),
+    roleId: expectBodyString(input, "roleId"),
+    hookEvent: expectBodyString(input, "hookEvent"),
+  });
+  return {
+    ok: true,
+    roleId: result.agent.roleId,
+    status: result.agent.status,
+    statusPath: result.statusPath,
+  };
+}
+
+async function claimDashboardTeamMessages(homeDir: string, body: unknown): Promise<unknown> {
+  const input = expectRequestBody(body);
+  const runId = expectBodyString(input, "runId");
+  const roleId = expectBodyString(input, "roleId");
+  const messages = await readPendingTeamMessagesForRole({
+    homeDir,
+    runId,
+    roleId,
+    limit: optionalBodyNumber(input.limit),
+  });
+  return {
+    runId,
+    roleId,
+    messages,
+  };
+}
+
+async function markDashboardTeamMessagesDelivered(
+  homeDir: string,
+  body: unknown,
+): Promise<unknown> {
+  const input = expectRequestBody(body);
+  const messageIdsValue = input.messageIds;
+  if (!Array.isArray(messageIdsValue)) throw new Error("Expected body.messageIds array.");
+  const messageIds = messageIdsValue.map((value) => {
+    if (typeof value !== "string" || value.length === 0) {
+      throw new Error("Expected body.messageIds to contain non-empty strings.");
+    }
+    return value;
+  });
+  await markTeamMessagesDelivered({
+    homeDir,
+    runId: expectBodyString(input, "runId"),
+    roleId: expectBodyString(input, "roleId"),
+    messageIds,
+  });
+  return { ok: true, delivered: messageIds };
+}
+
 async function spawnDashboardTeamRole(
   homeDir: string,
   body: unknown,
@@ -752,17 +812,6 @@ function describeError(error: unknown): string {
   return error instanceof Error ? error.message : String(error);
 }
 
-async function collectNamedFiles(root: string, name: string): Promise<string[]> {
-  const entries = await readdir(root, { withFileTypes: true });
-  const files: string[] = [];
-  for (const entry of entries) {
-    const path = join(root, entry.name);
-    if (entry.isDirectory()) files.push(...(await collectNamedFiles(path, name)));
-    else if (entry.isFile() && entry.name === name) files.push(path);
-  }
-  return files;
-}
-
 function ok(data: unknown, warnings: string[]): { status: number; body: DaemonResponseBody } {
   return { status: 200, body: { ok: true, data: sanitizeMetadata(data), warnings } };
 }