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

package/src/config/store.ts

@@ -22,6 +22,7 @@ import {
 export interface CoreConfigStore {
   readonly paths: EvoDevPaths;
   ensureBaseDirs(): Promise<void>;
+  ensureKnowledgeBase(): Promise<void>;
   readSettings(): Promise<EvoDevSettings>;
   writeSettings(settings: EvoDevSettings): Promise<void>;
   mergeAndWriteSettings(input: SettingsInput): Promise<EvoDevSettings>;
@@ -40,6 +41,15 @@ export function createCoreConfigStore(homeDir?: string): CoreConfigStore {
     paths,
     async ensureBaseDirs() {
       await mkdir(paths.stateDir, { recursive: true });
+      await mkdir(paths.logsDir, { recursive: true });
+      await mkdir(paths.knowledgeDir, { recursive: true });
+      await mkdir(paths.evosCasesDir, { recursive: true });
+      await mkdir(paths.roleAgentsDir, { recursive: true });
+      await mkdir(paths.teamsDir, { recursive: true });
+      await mkdir(paths.runsDir, { recursive: true });
+    },
+    async ensureKnowledgeBase() {
+      await ensureKnowledgeBaseFiles(paths);
     },
     async readSettings() {
       return readJsonFile(paths.settingsPath, parseSettings);
@@ -81,6 +91,7 @@ export function createCoreConfigStore(homeDir?: string): CoreConfigStore {
 export async function initializeCoreConfig(homeDir?: string): Promise<CoreConfigStore> {
   const store = createCoreConfigStore(homeDir);
   await store.ensureBaseDirs();
+  await store.ensureKnowledgeBase();
   await writeIfMissing(store.paths.settingsPath, createDefaultSettings());
   await writeIfMissing(store.paths.registryPath, createDefaultRegistry());
   await writeIfMissing(store.paths.installStatePath, createDefaultInstallState());
@@ -88,6 +99,87 @@ export async function initializeCoreConfig(homeDir?: string): Promise<CoreConfig
   return store;
 }
 
+export async function ensureKnowledgeBaseFiles(paths: EvoDevPaths): Promise<void> {
+  await mkdir(paths.knowledgeDir, { recursive: true });
+  await mkdir(paths.evosCasesDir, { recursive: true });
+  await writeTextIfMissing(
+    `${paths.knowledgeDir}/README.md`,
+    [
+      "# EvoDev Knowledge",
+      "",
+      "Local-private knowledge base for user-accepted facts, decisions, architecture notes, and reusable domain context.",
+      "",
+      "EvoDev must not populate this directory from source code, prompts, command output, logs, or transcripts without an explicit consent flow.",
+      "",
+    ].join("\n"),
+  );
+  await writeIndexIfMissingOrMigrate(paths.knowledgeIndexPath, "knowledge-index", {
+    version: 1,
+    kind: "knowledge-index",
+    roleTags: [],
+    entries: [],
+  });
+  await writeTextIfMissing(
+    `${paths.evosDir}/README.md`,
+    [
+      "# EvoDev Evos",
+      "",
+      "Local-private evolution case library for reviewed improvement cases and reusable process changes.",
+      "",
+      "Cases start empty. Future automation may propose candidates, but accepted evos require explicit review before they can influence workflows or routing.",
+      "",
+    ].join("\n"),
+  );
+  await writeTextIfMissing(
+    `${paths.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("\n"),
+  );
+  await writeIndexIfMissingOrMigrate(paths.evosIndexPath, "evos-index", {
+    version: 1,
+    kind: "evos-index",
+    roleTags: [],
+    cases: [],
+  });
+  await writeTextIfMissing(
+    `${paths.roleAgentsDir}/README.md`,
+    [
+      "# Role Agents",
+      "",
+      "Local-private role agent registry for EvoDev-managed agent roles and user-reviewed role extensions.",
+      "",
+      "Repository-specific role agents should be proposed first and written into a user repository only after explicit project opt-in.",
+      "",
+    ].join("\n"),
+  );
+  await writeIndexIfMissingOrMigrate(paths.roleAgentsIndexPath, "role-agent-index", {
+    version: 1,
+    kind: "role-agent-index",
+    roles: [],
+    projectExtensions: [],
+  });
+  await writeTextIfMissing(
+    `${paths.teamsDir}/README.md`,
+    [
+      "# Agent Teams",
+      "",
+      "Local-private EvoHub team registry for reviewed role-agent team definitions.",
+      "",
+      "Teams may reference role agents and role-tagged knowledge, but they must not contain raw source, prompts, transcripts, secrets, or raw command output.",
+      "",
+    ].join("\n"),
+  );
+  await writeIndexIfMissingOrMigrate(paths.teamsIndexPath, "agent-team-index", {
+    version: 1,
+    kind: "agent-team-index",
+    teams: [],
+  });
+}
+
 async function readJsonFile<T>(filePath: string, parse: (value: unknown) => T): Promise<T> {
   let raw: string;
 
@@ -148,6 +240,60 @@ async function writeIfMissing(filePath: string, value: unknown): Promise<void> {
   }
 }
 
+async function writeIndexIfMissingOrMigrate(
+  filePath: string,
+  kind: string,
+  defaults: Record<string, unknown>,
+): Promise<void> {
+  let raw: string;
+  try {
+    raw = await readFile(filePath, "utf8");
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") {
+      await writeJsonFile(filePath, defaults);
+      return;
+    }
+
+    throw new EvoDevConfigError(
+      `Cannot inspect config file (${describeFileError(error)})`,
+      filePath,
+    );
+  }
+
+  let existing: unknown;
+  try {
+    existing = JSON.parse(raw);
+  } catch (error) {
+    throw new EvoDevConfigError(
+      `Invalid bootstrap index JSON (${describeFileError(error)})`,
+      filePath,
+    );
+  }
+
+  if (!isRecord(existing) || existing.kind !== kind) return;
+
+  const migrated = { ...defaults, ...existing };
+  if (Object.keys(defaults).every((key) => key in existing)) return;
+  await writeJsonFile(filePath, migrated);
+}
+
+async function writeTextIfMissing(filePath: string, value: string): Promise<void> {
+  try {
+    await readFile(filePath, "utf8");
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") {
+      await mkdir(dirname(filePath), { recursive: true });
+      await writeFile(filePath, value, "utf8");
+      return;
+    }
+
+    throw new EvoDevConfigError(
+      `Cannot inspect config file (${describeFileError(error)})`,
+      filePath,
+    );
+  }
+}
+
 async function writeJsonFile(filePath: string, value: unknown): Promise<void> {
   await mkdir(dirname(filePath), { recursive: true });
   await writeFile(filePath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
@@ -164,3 +310,7 @@ function describeFileError(error: unknown): string {
 function isNodeError(error: unknown): error is NodeJS.ErrnoException {
   return error instanceof Error && "code" in error;
 }
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/src/daemon/index.ts

@@ -2,7 +2,17 @@ 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 { listObservabilityEvents } from "../observability/index.ts";
+import {
+  type TeamRuntimeAdapter,
+  listTeamRuns,
+  reconcileTeamRun,
+  resumeTeamRun,
+  sendTeamMessage,
+  spawnTeamRole,
+  stopTeamRole,
+} from "../team/index.ts";
 
 export interface DaemonPaths {
   rootDir: string;
@@ -43,6 +53,15 @@ export interface DaemonRequestInput {
   token?: string | null;
   homeDir: string;
   origin?: string | null;
+  body?: unknown;
+  runtimeAdapter?: TeamRuntimeAdapter;
+}
+
+interface DaemonTeamStatusSummary {
+  run: unknown;
+  agents: unknown[];
+  stoppedAgents: string[];
+  notifications: unknown[];
 }
 
 const DEFAULT_PORT = 37645;
@@ -163,6 +182,39 @@ 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") {
+    return dashboardMutation(
+      await sendDashboardTeamMessage(input.homeDir, input.body, input.runtimeAdapter),
+      warnings,
+    );
+  }
+  if (input.path === "/teams/spawn" && input.method === "POST") {
+    return dashboardMutation(
+      await spawnDashboardTeamRole(input.homeDir, input.body, input.runtimeAdapter),
+      warnings,
+    );
+  }
+  if (input.path === "/teams/stop-role" && input.method === "POST") {
+    return dashboardMutation(
+      await stopDashboardTeamRole(input.homeDir, input.body, input.runtimeAdapter),
+      warnings,
+    );
+  }
+  if (input.path === "/teams/resume" && input.method === "POST") {
+    return dashboardMutation(
+      await resumeDashboardTeamRun(input.homeDir, input.body, input.runtimeAdapter),
+      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),
+      warnings,
+    );
+  }
   if (input.method !== "GET") return notFound(warnings);
 
   if (input.path === "/tasks")
@@ -181,8 +233,16 @@ export async function handleDaemonRequest(
       await collectDirectorySummaries(join(input.homeDir, ".evodev", "PACKS"), warnings),
       warnings,
     );
-  if (input.path === "/runs") return ok([], warnings);
-  if (input.path === "/agents") return ok([], warnings);
+  if (input.path === "/runs") return ok(await collectTeamRuns(input.homeDir, warnings), warnings);
+  if (input.path === "/evolution/triggers")
+    return ok(await collectEvolutionTriggers(input.homeDir, warnings), warnings);
+  if (input.path === "/agents")
+    return ok(
+      (await collectTeamStatus(input.homeDir, warnings, input.runtimeAdapter)).agents,
+      warnings,
+    );
+  if (input.path === "/teams/status")
+    return ok(await collectTeamStatus(input.homeDir, warnings, input.runtimeAdapter), warnings);
 
   return notFound(warnings);
 }
@@ -211,6 +271,7 @@ export async function runDaemonForeground(input: {
           url.searchParams.get("token"),
         homeDir: input.homeDir,
         origin: readHeader(request, "origin"),
+        body: await readJsonBody(request),
       });
 
       response.writeHead(result.status, { "content-type": "application/json" });
@@ -248,8 +309,22 @@ export async function runDaemonForeground(input: {
   input.write?.(
     `Daemon listening on ${state.lock.host}:${state.lock.port}; token path: ${state.paths.tokenPath}`,
   );
+  const reconcileInterval = setInterval(() => {
+    void reconcileTeamRun({ homeDir: input.homeDir }).catch(() => undefined);
+  }, 2_000);
+  reconcileInterval.unref();
+  const evolutionInterval = setInterval(() => {
+    void processEvolutionTriggers({ homeDir: input.homeDir, limit: 20 })
+      .then(() => clearDaemonEvolutionProcessError(input.homeDir))
+      .catch((error) => recordDaemonEvolutionProcessError(input.homeDir, error));
+  }, 5_000);
+  evolutionInterval.unref();
   await new Promise<void>((resolve, reject) => {
-    server.once("close", resolve);
+    server.once("close", () => {
+      clearInterval(reconcileInterval);
+      clearInterval(evolutionInterval);
+      resolve();
+    });
     server.once("error", reject);
   });
 }
@@ -264,6 +339,22 @@ function createDaemonToken(): string {
   return randomBytes(32).toString("hex");
 }
 
+async function readJsonBody(request: IncomingMessage): Promise<unknown> {
+  if (request.method === "GET" || request.method === "HEAD") return undefined;
+  const chunks: Buffer[] = [];
+  let totalBytes = 0;
+  for await (const chunk of request) {
+    const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk));
+    totalBytes += buffer.length;
+    if (totalBytes > 64 * 1024) throw new Error("Request body too large.");
+    chunks.push(buffer);
+  }
+  if (chunks.length === 0) return undefined;
+  const raw = Buffer.concat(chunks).toString("utf8").trim();
+  if (raw === "") return undefined;
+  return JSON.parse(raw);
+}
+
 async function authorize(homeDir: string, token: string | null): Promise<{ ok: boolean }> {
   const expected = await readDaemonToken(homeDir);
   return { ok: expected !== null && token !== null && token === expected };
@@ -352,6 +443,203 @@ async function collectLearningCandidateSummaries(
   });
 }
 
+async function collectEvolutionTriggers(homeDir: string, warnings: string[]): Promise<unknown[]> {
+  const lastError = await readDaemonEvolutionProcessError(homeDir).catch(() => null);
+  if (lastError !== null) warnings.push(`Evolution processor last error: ${lastError}`);
+  try {
+    return (await listEvolutionTriggers({ homeDir })).map((trigger) =>
+      sanitizeMetadata({
+        id: trigger.id,
+        projectKey: trigger.projectKey,
+        runId: trigger.runId,
+        roleId: trigger.roleId,
+        taskId: trigger.taskId,
+        eventType: trigger.eventType,
+        triggerStrength: trigger.triggerStrength,
+        triggerReason: trigger.triggerReason,
+        status: trigger.status,
+        attempts: trigger.attempts,
+        createdAt: trigger.createdAt,
+        updatedAt: trigger.updatedAt,
+      }),
+    );
+  } catch (error) {
+    warnings.push(`Evolution triggers unavailable: ${describeError(error)}`);
+    return [];
+  }
+}
+
+async function processDashboardEvolutionTriggers(homeDir: string, body: unknown): Promise<unknown> {
+  if (body === undefined) {
+    return {
+      ok: false,
+      error: "evolution process requires JSON body with dryRun=true or confirm=true.",
+    };
+  }
+  const input = expectRequestBody(body);
+  const dryRun = optionalBodyBoolean(input.dryRun) === true;
+  const confirm = optionalBodyBoolean(input.confirm) === true;
+  if (!dryRun && !confirm) {
+    return {
+      ok: false,
+      error: "evolution process requires dryRun=true or confirm=true.",
+    };
+  }
+  return processEvolutionTriggers({
+    homeDir,
+    projectKey: optionalBodyString(input.projectKey),
+    runId: optionalBodyString(input.runId),
+    limit: optionalBodyNumber(input.limit),
+    dryRun,
+  });
+}
+
+async function collectTeamRuns(homeDir: string, warnings: string[]): Promise<unknown[]> {
+  try {
+    return (await listTeamRuns({ homeDir })).map((run) =>
+      sanitizeMetadata({
+        runId: run.runId,
+        status: run.status,
+        repoRoot: run.repoRoot,
+        mainAgentId: run.mainAgentId,
+        session: run.tmux.session,
+        roleCount: Object.keys(run.roles).length,
+        createdAt: run.createdAt,
+        updatedAt: run.updatedAt,
+      }),
+    );
+  } catch (error) {
+    warnings.push(`Team runs unavailable: ${describeError(error)}`);
+    return [];
+  }
+}
+
+async function collectTeamStatus(
+  homeDir: string,
+  warnings: string[],
+  runtimeAdapter?: TeamRuntimeAdapter,
+): Promise<DaemonTeamStatusSummary> {
+  try {
+    const status = await reconcileTeamRun({ homeDir, runtimeAdapter });
+    return sanitizeMetadata({
+      run:
+        status.run === null
+          ? null
+          : {
+              runId: status.run.runId,
+              status: status.run.status,
+              repoRoot: status.run.repoRoot,
+              session: status.run.tmux.session,
+              updatedAt: status.run.updatedAt,
+            },
+      agents: status.agents.map((agent) => ({
+        roleId: agent.roleId,
+        roleName: agent.roleName,
+        runId: agent.runId,
+        runtime: agent.runtime,
+        model: agent.model,
+        thinkingLevel: agent.thinkingLevel,
+        status: agent.status,
+        paneId: agent.tmux.paneId,
+        canReceiveMessages:
+          agent.status === "running" ||
+          agent.status === "recovering" ||
+          agent.status === "recreated",
+        nativeSessionRecorded: agent.nativeSession.sessionId !== null,
+        updatedAt: agent.updatedAt,
+      })),
+      stoppedAgents: status.stoppedAgents.map((agent) => agent.roleId),
+      notifications: status.notifications.map((notification) => ({
+        ok: notification.ok,
+        error: notification.error ?? null,
+        deliveredTo: notification.deliveredTo ?? null,
+      })),
+    }) as DaemonTeamStatusSummary;
+  } catch (error) {
+    warnings.push(`Team status unavailable: ${describeError(error)}`);
+    return { run: null, agents: [], stoppedAgents: [], notifications: [] };
+  }
+}
+
+async function sendDashboardTeamMessage(
+  homeDir: string,
+  body: unknown,
+  runtimeAdapter?: TeamRuntimeAdapter,
+): Promise<unknown> {
+  const input = expectRequestBody(body);
+  return sendTeamMessage({
+    homeDir,
+    runId: optionalBodyString(input.runId),
+    fromRoleId: "user",
+    toRoleId: expectBodyString(input, "toRoleId"),
+    message: expectBodyString(input, "message"),
+    runtimeAdapter,
+  });
+}
+
+async function spawnDashboardTeamRole(
+  homeDir: string,
+  body: unknown,
+  runtimeAdapter?: TeamRuntimeAdapter,
+): Promise<unknown> {
+  const input = expectRequestBody(body);
+  const roleId = expectBodyString(input, "roleId");
+  const status = await reconcileTeamRun({
+    homeDir,
+    runId: optionalBodyString(input.runId),
+    runtimeAdapter,
+    notifyMain: false,
+  });
+  if (status.run === null) return { ok: false, error: "team-run-not-found" };
+  if (status.run.status !== "running") return { ok: false, error: "team-run-not-running" };
+  const result = await spawnTeamRole({
+    homeDir,
+    repoRoot: status.run.repoRoot,
+    runId: status.run.runId,
+    roleId,
+    runtimeAdapter,
+  });
+  return { ok: true, created: result.created, agent: result.agent };
+}
+
+async function stopDashboardTeamRole(
+  homeDir: string,
+  body: unknown,
+  runtimeAdapter?: TeamRuntimeAdapter,
+): Promise<unknown> {
+  const input = expectRequestBody(body);
+  return stopTeamRole({
+    homeDir,
+    runId: optionalBodyString(input.runId),
+    roleId: expectBodyString(input, "roleId"),
+    runtimeAdapter,
+  });
+}
+
+async function resumeDashboardTeamRun(
+  homeDir: string,
+  body: unknown,
+  runtimeAdapter?: TeamRuntimeAdapter,
+): Promise<unknown> {
+  const input = expectRequestBody(body);
+  const decision = optionalBodyString(input.onSessionMissing);
+  if (decision !== undefined && !["ask", "fail", "recreate", "resume-latest"].includes(decision)) {
+    return { ok: false, error: "invalid-on-session-missing" };
+  }
+  const result = await resumeTeamRun({
+    homeDir,
+    runId: optionalBodyString(input.runId),
+    runtimeAdapter,
+    missingSessionDecision: decision as "ask" | "fail" | "recreate" | "resume-latest" | undefined,
+  });
+  return {
+    ok: result.decisionRequired.length === 0,
+    run: result.run,
+    outcomes: result.outcomes,
+    decisionRequired: result.decisionRequired,
+  };
+}
+
 async function collectDirectorySummaries(root: string, warnings: string[]): Promise<unknown[]> {
   if (!(await pathExists(root))) {
     warnings.push(`Store not found: ${root}`);
@@ -379,6 +667,91 @@ function sanitizeMetadata(value: unknown): unknown {
   return output;
 }
 
+function dashboardMutation(
+  data: unknown,
+  warnings: string[],
+): { status: number; body: DaemonResponseBody } {
+  const okResult = !(
+    typeof data === "object" &&
+    data !== null &&
+    "ok" in data &&
+    (data as { ok?: unknown }).ok === false
+  );
+  return {
+    status: okResult ? 200 : 400,
+    body: { ok: okResult, data: sanitizeMetadata(data), warnings },
+  };
+}
+
+function expectRequestBody(value: unknown): Record<string, unknown> {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new Error("Expected JSON object request body.");
+  }
+  return value as Record<string, unknown>;
+}
+
+function expectBodyString(input: Record<string, unknown>, key: string): string {
+  const value = input[key];
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(`Expected non-empty string body.${key}.`);
+  }
+  return value;
+}
+
+function optionalBodyString(value: unknown): string | undefined {
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+
+function optionalBodyNumber(value: unknown): number | undefined {
+  return typeof value === "number" && Number.isInteger(value) && value > 0 ? value : undefined;
+}
+
+function optionalBodyBoolean(value: unknown): boolean | undefined {
+  return typeof value === "boolean" ? value : undefined;
+}
+
+function resolveDaemonEvolutionProcessErrorPath(homeDir: string): string {
+  return join(resolveDaemonPaths(homeDir).rootDir, "evolution-process-error.json");
+}
+
+async function recordDaemonEvolutionProcessError(homeDir: string, error: unknown): Promise<void> {
+  try {
+    const path = resolveDaemonEvolutionProcessErrorPath(homeDir);
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(
+      path,
+      `${JSON.stringify(
+        {
+          schemaVersion: 1,
+          kind: "daemon-evolution-process-error",
+          updatedAt: new Date().toISOString(),
+          summary: sanitizeMetadata(describeError(error)),
+        },
+        null,
+        2,
+      )}\n`,
+      { encoding: "utf8", flag: "w", mode: 0o600 },
+    );
+  } catch {
+    // Daemon background diagnostics must not affect foreground request handling.
+  }
+}
+
+async function clearDaemonEvolutionProcessError(homeDir: string): Promise<void> {
+  await rm(resolveDaemonEvolutionProcessErrorPath(homeDir), { force: true }).catch(() => undefined);
+}
+
+async function readDaemonEvolutionProcessError(homeDir: string): Promise<string | null> {
+  const path = resolveDaemonEvolutionProcessErrorPath(homeDir);
+  if (!(await pathExists(path))) return null;
+  const value = JSON.parse(await readFile(path, "utf8")) as { summary?: unknown };
+  return typeof value.summary === "string" && value.summary.length > 0 ? value.summary : null;
+}
+
+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[] = [];