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

package/src/config/settings.ts

@@ -1,5 +1,7 @@
+import { readFile } from "node:fs/promises";
 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 +9,13 @@ export interface PluginSettings {
   autoSyncAgents?: boolean;
 }
 
+export interface MemorySettings {
+  autoAccept: boolean;
+  runtimeInjection: boolean;
+  staleReview: boolean;
+  lexicalIndex: boolean;
+}
+
 export interface EvoDevSettings {
   version: 1;
   platform: {
@@ -29,6 +38,7 @@ export interface EvoDevSettings {
   };
   hooks: HookSettings;
   teamRuntime: TeamRuntimeSettings;
+  memory: MemorySettings;
 }
 
 export type SettingsInput = Partial<{
@@ -45,6 +55,7 @@ export type SettingsInput = Partial<{
   doctor: Partial<EvoDevSettings["doctor"]>;
   hooks: unknown;
   teamRuntime: Partial<TeamRuntimeSettings>;
+  memory: Partial<MemorySettings>;
 }>;
 
 export interface TeamRuntimeSettings {
@@ -52,6 +63,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 +95,7 @@ export function createDefaultSettings(os: string = process.platform): EvoDevSett
     },
     hooks: createDefaultHookSettings(),
     teamRuntime: createDefaultTeamRuntimeSettings(),
+    memory: createDefaultMemorySettings(),
   };
 }
 
@@ -92,6 +105,16 @@ 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,
   };
 }
 
@@ -135,11 +158,25 @@ export function mergeSettings(
       ...defaults.teamRuntime,
       ...existing.teamRuntime,
     },
+    memory: {
+      ...defaults.memory,
+      ...existing.memory,
+    },
   };
 
   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 +221,35 @@ export function parseSettings(value: unknown): EvoDevSettings {
       root.teamRuntime ?? createDefaultTeamRuntimeSettings(),
       "settings.teamRuntime",
     ),
+    memory: parseMemorySettings(root.memory ?? createDefaultMemorySettings(), "settings.memory"),
   };
 
   return parsed;
 }
 
+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`),
+  };
+}
+
 function parseTeamRuntimeSettings(value: unknown, path: string): TeamRuntimeSettings {
   const input = expectRecord(value, path);
   const defaults = createDefaultTeamRuntimeSettings();
@@ -211,9 +272,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 +311,12 @@ function expectRecord(value: unknown, path: string): Record<string, unknown> {
   return value as Record<string, unknown>;
 }
 
+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 "../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

@@ -6,12 +6,19 @@ import { listEvolutionTriggers, processEvolutionTriggers } from "../evolution/in
 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),
@@ -541,10 +575,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 +585,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 +611,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,