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

package/dist/index.js

@@ -7360,7 +7360,7 @@ function isRecord6(value) {
 // packages/core/src/team/index.ts
 import { spawn } from "node:child_process";
 import { appendFile as appendFile2, cp, mkdir as mkdir6, readFile as readFile7, readdir as readdir5, stat as stat6, writeFile as writeFile5 } from "node:fs/promises";
-import { basename as basename3, dirname as dirname6, join as join7 } from "node:path";
+import { basename as basename3, dirname as dirname6, extname, isAbsolute as isAbsolute5, join as join7, relative as relative6, resolve as resolve4 } from "node:path";
 
 // packages/core/src/team/prompts.ts
 var TEAM_ROLE_STARTUP_PROMPT_TEMPLATE = [
@@ -7538,6 +7538,23 @@ var BUILT_IN_ROLE_PROMPTS = {
     prompt: "You are the implementation executor for this EvoDev team run. Keep changes scoped, avoid taking conductor decisions, and report changed files plus verification evidence."
   }
 };
+var BUILT_IN_TEAM_DEFINITION = {
+  version: 1,
+  name: "builtin-minimal-team",
+  description: "Built-in minimal EvoDev team fallback.",
+  agents: {
+    executor: "builtin:executor",
+    reviewer: "builtin:reviewer",
+    tester: "builtin:tester"
+  },
+  body: [
+    "# Built-in Minimal Team",
+    "",
+    "Use role agents only when delegation improves correctness, coverage, safety, or latency.",
+    "Spawn roles on demand and send self-contained assignments through Teams MCP."
+  ].join(`
+`)
+};
 function createTeamRunStore(homeDir) {
   const paths = resolveTeamRunPaths(homeDir);
   return {
@@ -8541,9 +8558,188 @@ async function listTeamAgents(input = {}) {
     isMidTurn: isMidTurnTeamAgentStatus(agent.status)
   }));
 }
+async function resolveTeamOverlay(input) {
+  const repoTeamPath = join7(input.repoRoot, ".evodev", "team", "team.md");
+  if (await pathExists5(repoTeamPath)) {
+    return {
+      source: "repo",
+      teamPath: repoTeamPath,
+      definition: parseTeamDefinitionMarkdown(await readFile7(repoTeamPath, "utf8"))
+    };
+  }
+  const globalTeamPath = resolveGlobalTeamMarkdownPath(input.homeDir);
+  if (await pathExists5(globalTeamPath)) {
+    return {
+      source: "global",
+      teamPath: globalTeamPath,
+      definition: parseTeamDefinitionMarkdown(await readFile7(globalTeamPath, "utf8"))
+    };
+  }
+  return {
+    source: "builtin",
+    teamPath: null,
+    definition: BUILT_IN_TEAM_DEFINITION
+  };
+}
+async function ensureDefaultTeamOverlay(input) {
+  const assets = await listDefaultTeamOverlayAssets(input.assetsRootDir);
+  const paths = resolveEvoDevPaths(input.homeDir);
+  const files = [];
+  for (const asset of assets) {
+    const targetPath = asset.kind === "team" ? join7(paths.rootDir, "team", "team.md") : join7(paths.rootDir, "team", "agents", asset.name);
+    const content = await readFile7(asset.sourcePath, "utf8");
+    files.push({
+      sourcePath: asset.sourcePath,
+      targetPath,
+      written: await writeTextFileIfMissing(targetPath, content)
+    });
+  }
+  return { files };
+}
+function parseTeamDefinitionMarkdown(content) {
+  const markdown = parseMarkdownWithFrontmatter(content);
+  const frontmatter = markdown.frontmatter;
+  const version = frontmatter.version;
+  if (version !== 1)
+    throw new Error("team.md frontmatter version must be 1.");
+  const agents = parseTeamDefinitionAgents(frontmatter.agents);
+  return {
+    version: 1,
+    name: optionalString4(frontmatter.name) ?? "evodev-team",
+    description: optionalString4(frontmatter.description) ?? "EvoDev team overlay.",
+    agents,
+    body: markdown.body.trim()
+  };
+}
+function resolveTeamAgentReference(input) {
+  assertSafeId(input.roleId, "roleId");
+  const reference = input.reference.trim();
+  if (reference.startsWith("global:")) {
+    const name = reference.slice("global:".length);
+    assertSafeId(name, "global agent name");
+    return {
+      roleId: input.roleId,
+      reference,
+      sourcePath: join7(resolveEvoDevPaths(input.homeDir).rootDir, "team", "agents", `${name}.md`),
+      scope: "global"
+    };
+  }
+  if (reference.includes(":")) {
+    throw new Error(`Unsupported team agent reference for ${input.roleId}: ${reference}`);
+  }
+  if (isAbsolute5(reference)) {
+    throw new Error(`Team agent path for ${input.roleId} must be repo-relative.`);
+  }
+  const sourcePath = resolve4(input.repoRoot, reference);
+  const relativePath = relative6(input.repoRoot, sourcePath);
+  if (relativePath === "" || relativePath.startsWith("..") || isAbsolute5(relativePath) || extname(sourcePath) !== ".md") {
+    throw new Error(`Team agent path for ${input.roleId} must be a repo-local Markdown file.`);
+  }
+  return {
+    roleId: input.roleId,
+    reference,
+    sourcePath,
+    scope: "repo"
+  };
+}
+async function readTeamAgentSummary(input) {
+  const reference = resolveTeamAgentReference(input);
+  const markdown = await readTeamAgentMarkdown(reference);
+  const parsed = parseMarkdownWithFrontmatter(markdown);
+  return {
+    roleId: input.roleId,
+    name: optionalString4(parsed.frontmatter.name) ?? defaultRoleName(input.roleId),
+    description: optionalString4(parsed.frontmatter.description) ?? `EvoDev ${input.roleId} role agent.`,
+    sourcePath: reference.sourcePath
+  };
+}
+async function readTeamAgentDefinition(input) {
+  const reference = resolveTeamAgentReference(input);
+  const markdown = await readTeamAgentMarkdown(reference);
+  const parsed = parseMarkdownWithFrontmatter(markdown);
+  const evodev = isRecord7(parsed.frontmatter.evodev) ? parsed.frontmatter.evodev : {};
+  return {
+    roleId: input.roleId,
+    name: optionalString4(parsed.frontmatter.name) ?? defaultRoleName(input.roleId),
+    description: optionalString4(parsed.frontmatter.description) ?? `EvoDev ${input.roleId} role agent.`,
+    runtime: optionalRuntime(evodev.runtime),
+    model: optionalNullableString(parsed.frontmatter.model) ?? null,
+    thinkingLevel: optionalNullableString(evodev.thinking) ?? optionalNullableString(evodev.thinkingLevel) ?? null,
+    writeMode: optionalWriteMode(evodev.writeMode),
+    skills: parseStringList(evodev.skills),
+    sourcePath: reference.sourcePath,
+    markdown
+  };
+}
+async function renderMainTeamOverlayContext(input) {
+  const overlay = input.overlay ?? await resolveTeamOverlay(input);
+  const summaries = await readTeamOverlayAgentSummaries({
+    homeDir: input.homeDir,
+    repoRoot: input.repoRoot,
+    overlay
+  });
+  const roleLines = summaries.length === 0 ? ["- none declared"] : summaries.map((summary) => `- ${summary.roleId}: ${summary.name} - ${summary.description}`);
+  const source = overlay.teamPath === null ? `${overlay.source} fallback` : `${overlay.source}: ${overlay.teamPath}`;
+  return [
+    "EvoDev team overlay:",
+    `Team: ${overlay.definition.name}`,
+    `Description: ${overlay.definition.description}`,
+    `Source: ${source}`,
+    "",
+    "Team strategy:",
+    overlay.definition.body || "(none)",
+    "",
+    "Declared role agents:",
+    ...roleLines,
+    "",
+    "Overlay rules:",
+    "- Declared role agents are spawned only on demand.",
+    "- Delegate by role id; role agent Markdown is loaded only inside the spawned role."
+  ].join(`
+`);
+}
+function renderRoleAgentDefinitionContext(input) {
+  return [
+    "EvoDev role agent Markdown definition:",
+    `Source path: ${input.definition.sourcePath}`,
+    "Use this Markdown as the role-specific operating definition for this role only.",
+    "<evodev-agent-markdown>",
+    input.definition.markdown.trimEnd(),
+    "</evodev-agent-markdown>"
+  ].join(`
+`);
+}
 async function resolveTeamRole(input) {
   assertSafeId(input.roleId, "roleId");
   const settings = await readSettingsOrDefault(input.homeDir);
+  const overlay = await resolveTeamOverlay({ homeDir: input.homeDir, repoRoot: input.repoRoot });
+  if (overlay.source !== "builtin" && input.roleId !== "main") {
+    const reference = overlay.definition.agents[input.roleId];
+    if (reference === undefined) {
+      throw new Error(`Role ${input.roleId} is not declared in team overlay ${overlay.teamPath ?? overlay.source}.`);
+    }
+    const agent = await readTeamAgentDefinition({
+      homeDir: input.homeDir,
+      repoRoot: input.repoRoot,
+      roleId: input.roleId,
+      reference
+    });
+    return {
+      version: 1,
+      roleId: input.roleId,
+      roleName: agent.name,
+      description: agent.description,
+      runtime: agent.runtime ?? settings.teamRuntime.defaultRuntime,
+      model: agent.model ?? settings.teamRuntime.defaultModel,
+      thinkingLevel: agent.thinkingLevel ?? settings.teamRuntime.defaultThinkingLevel,
+      prompt: renderRoleAgentDefinitionContext({ definition: agent }),
+      permissions: parseRolePermissions({ writeMode: agent.writeMode ?? undefined }, false),
+      teamPolicy: parseRolePolicy(undefined, settings.teamRuntime.recordTranscript),
+      source: "overlay",
+      sourcePath: agent.sourcePath,
+      nativeAgent: null
+    };
+  }
   const globalRolePath = join7(resolveEvoDevPaths(input.homeDir).roleAgentsDir, `${input.roleId}.json`);
   const candidate = await readRoleCandidate(globalRolePath, "global");
   const nativeAgent = await resolveTeamRoleNativeAgentBinding({
@@ -8562,11 +8758,17 @@ async function resolveTeamRole(input) {
     defaultThinkingLevel: settings.teamRuntime.defaultThinkingLevel,
     recordTranscript: settings.teamRuntime.recordTranscript
   });
+  const prompt = input.roleId === "main" ? appendPromptBlock(parsed.prompt, await renderMainTeamOverlayContext({
+    homeDir: input.homeDir,
+    repoRoot: input.repoRoot,
+    overlay
+  })) : parsed.prompt;
   return {
     ...parsed,
     runtime: input.overrides?.runtime ?? nativeAgent?.target ?? parsed.runtime,
     model: input.overrides?.model ?? parsed.model,
     thinkingLevel: input.overrides?.thinkingLevel ?? parsed.thinkingLevel,
+    prompt,
     sourcePath,
     nativeAgent
   };
@@ -8796,7 +8998,7 @@ class TmuxRuntimeAdapter {
 
 class NodeTeamRuntimeCommandRunner {
   async run(command, args, options = {}) {
-    return new Promise((resolve4, reject) => {
+    return new Promise((resolve5, reject) => {
       const child = spawn(command, args, { stdio: ["pipe", "pipe", "pipe"] });
       let stdout = "";
       let stderr = "";
@@ -8810,7 +9012,7 @@ class NodeTeamRuntimeCommandRunner {
       });
       child.once("error", reject);
       child.once("close", (code) => {
-        resolve4({ exitCode: code ?? 1, stdout, stderr });
+        resolve5({ exitCode: code ?? 1, stdout, stderr });
       });
       child.stdin.end(options.input ?? "");
     });
@@ -9075,6 +9277,206 @@ function createBuiltInRole(roleId, runtime) {
     prompt: builtin?.prompt ?? defaultRolePrompt(roleId)
   };
 }
+async function readTeamOverlayAgentSummaries(input) {
+  const entries = Object.entries(input.overlay.definition.agents);
+  if (input.overlay.source === "builtin") {
+    return entries.map(([roleId]) => {
+      const builtin = BUILT_IN_ROLE_PROMPTS[roleId];
+      return {
+        roleId,
+        name: builtin?.roleName ?? defaultRoleName(roleId),
+        description: builtin?.description ?? `EvoDev ${roleId} role agent.`,
+        sourcePath: "builtin"
+      };
+    });
+  }
+  return Promise.all(entries.map(([roleId, reference]) => readTeamAgentSummary({
+    homeDir: input.homeDir,
+    repoRoot: input.repoRoot,
+    roleId,
+    reference
+  })));
+}
+async function listDefaultTeamOverlayAssets(assetsRootDir) {
+  const teamPath = join7(assetsRootDir, "team", "team.md");
+  const agentsDir = join7(assetsRootDir, "team", "agents");
+  await assertReadableFile(teamPath, "Default team asset");
+  let entries;
+  try {
+    entries = await readdir5(agentsDir, { withFileTypes: true });
+  } catch (error) {
+    throw new Error(`Cannot read default team agents directory ${agentsDir}: ${describeError2(error)}`);
+  }
+  const agentFiles = entries.filter((entry) => entry.isFile() && extname(entry.name) === ".md").map((entry) => entry.name).sort();
+  if (agentFiles.length === 0) {
+    throw new Error(`Default team agents directory has no Markdown files: ${agentsDir}`);
+  }
+  return [
+    { kind: "team", sourcePath: teamPath, name: "team.md" },
+    ...agentFiles.map((name) => ({
+      kind: "agent",
+      sourcePath: join7(agentsDir, name),
+      name
+    }))
+  ];
+}
+async function assertReadableFile(path, label) {
+  try {
+    const info = await stat6(path);
+    if (!info.isFile())
+      throw new Error("not a file");
+  } catch (error) {
+    throw new Error(`${label} is not readable at ${path}: ${describeError2(error)}`);
+  }
+}
+async function writeTextFileIfMissing(path, content) {
+  try {
+    await readFile7(path, "utf8");
+    return false;
+  } catch (error) {
+    if (!isNotFoundError2(error)) {
+      throw new Error(`Cannot inspect ${path}: ${describeError2(error)}`);
+    }
+  }
+  await mkdir6(dirname6(path), { recursive: true });
+  await writeFile5(path, content.endsWith(`
+`) ? content : `${content}
+`, "utf8");
+  return true;
+}
+function parseTeamDefinitionAgents(value) {
+  if (value === undefined)
+    return {};
+  if (!isRecord7(value))
+    throw new Error("team.md agents must be a role-id map.");
+  const agents = {};
+  for (const [roleId, reference] of Object.entries(value)) {
+    assertSafeId(roleId, "team.md agents roleId");
+    if (typeof reference !== "string" || reference.trim() === "") {
+      throw new Error(`team.md agent reference for ${roleId} must be a non-empty string.`);
+    }
+    agents[roleId] = reference.trim();
+  }
+  return agents;
+}
+async function readTeamAgentMarkdown(reference) {
+  if (extname(reference.sourcePath) !== ".md") {
+    throw new Error(`Team agent file for ${reference.roleId} must be Markdown.`);
+  }
+  try {
+    return await readFile7(reference.sourcePath, "utf8");
+  } catch (error) {
+    if (isNotFoundError2(error)) {
+      throw new Error(`Team agent file not found for ${reference.roleId}: ${reference.sourcePath}`);
+    }
+    throw new Error(`Cannot read team agent file for ${reference.roleId}: ${reference.sourcePath}: ${describeError2(error)}`);
+  }
+}
+function parseMarkdownWithFrontmatter(content) {
+  const text = content.startsWith("\uFEFF") ? content.slice(1) : content;
+  const lines = text.split(/\r?\n/);
+  if (lines[0]?.trim() !== "---")
+    return { frontmatter: {}, body: text };
+  const end = lines.findIndex((line, index) => index > 0 && line.trim() === "---");
+  if (end < 0)
+    throw new Error("Markdown frontmatter is not closed.");
+  return {
+    frontmatter: parseSimpleYaml(lines.slice(1, end).join(`
+`)),
+    body: lines.slice(end + 1).join(`
+`)
+  };
+}
+function parseSimpleYaml(content) {
+  const root = {};
+  const stack = [
+    { indent: -1, value: root }
+  ];
+  const lines = content.split(/\r?\n/);
+  for (let index = 0;index < lines.length; index += 1) {
+    const rawLine = lines[index] ?? "";
+    if (rawLine.trim() === "" || rawLine.trimStart().startsWith("#"))
+      continue;
+    const indent = rawLine.match(/^ */)?.[0].length ?? 0;
+    const trimmed = rawLine.trim();
+    while (stack.length > 1 && indent <= stack[stack.length - 1].indent)
+      stack.pop();
+    const parent = stack[stack.length - 1].value;
+    if (trimmed.startsWith("- ")) {
+      if (!Array.isArray(parent))
+        throw new Error("Invalid YAML list item placement.");
+      parent.push(parseYamlScalar(trimmed.slice(2).trim()));
+      continue;
+    }
+    const separator = trimmed.indexOf(":");
+    if (separator <= 0)
+      throw new Error(`Invalid YAML line: ${trimmed}`);
+    const key = trimmed.slice(0, separator).trim();
+    const rawValue = trimmed.slice(separator + 1).trim();
+    if (!isRecord7(parent))
+      throw new Error(`Invalid YAML parent for key ${key}.`);
+    if (rawValue === "") {
+      const next = findNextYamlContentLine(lines, index + 1);
+      const value = next !== null && next.indent > indent && next.trimmed.startsWith("- ") ? [] : {};
+      parent[key] = value;
+      stack.push({ indent, value });
+      continue;
+    }
+    parent[key] = parseYamlScalar(rawValue);
+  }
+  return root;
+}
+function findNextYamlContentLine(lines, start) {
+  for (let index = start;index < lines.length; index += 1) {
+    const line = lines[index] ?? "";
+    if (line.trim() === "" || line.trimStart().startsWith("#"))
+      continue;
+    return {
+      indent: line.match(/^ */)?.[0].length ?? 0,
+      trimmed: line.trim()
+    };
+  }
+  return null;
+}
+function parseYamlScalar(value) {
+  if (value === "")
+    return "";
+  if (value === "true")
+    return true;
+  if (value === "false")
+    return false;
+  if (value === "null" || value === "~")
+    return null;
+  if (/^-?\d+(\.\d+)?$/.test(value))
+    return Number(value);
+  if (value.startsWith("[") && value.endsWith("]")) {
+    const inner = value.slice(1, -1).trim();
+    if (inner === "")
+      return [];
+    return inner.split(",").map((item) => parseYamlScalar(item.trim()));
+  }
+  if (value.startsWith('"') && value.endsWith('"')) {
+    try {
+      return JSON.parse(value);
+    } catch {
+      return value.slice(1, -1);
+    }
+  }
+  if (value.startsWith("'") && value.endsWith("'")) {
+    return value.slice(1, -1).replace(/''/g, "'");
+  }
+  return value;
+}
+function appendPromptBlock(prompt, block) {
+  if (block.trim() === "")
+    return prompt;
+  return `${prompt.trimEnd()}
+
+${block.trim()}`;
+}
+function resolveGlobalTeamMarkdownPath(homeDir) {
+  return join7(resolveEvoDevPaths(homeDir).rootDir, "team", "team.md");
+}
 function parseRolePermissions(value, main) {
   const input = isRecord7(value) ? value : {};
   return {
@@ -9187,6 +9589,13 @@ function parseRuntime(value, fallback) {
     return value;
   throw new Error("Role runtime must be codex or claude.");
 }
+function optionalRuntime(value) {
+  if (value === undefined || value === null)
+    return null;
+  if (value === "codex" || value === "claude")
+    return value;
+  throw new Error("Role evodev.runtime must be codex or claude.");
+}
 function parseWriteMode(value, fallback) {
   if (value === undefined || value === null)
     return fallback;
@@ -9195,6 +9604,20 @@ function parseWriteMode(value, fallback) {
   }
   throw new Error("Role writeMode is invalid.");
 }
+function optionalWriteMode(value) {
+  if (value === undefined || value === null)
+    return null;
+  return parseWriteMode(value, "repo-write");
+}
+function parseStringList(value) {
+  if (value === undefined || value === null)
+    return [];
+  if (typeof value === "string" && value.trim() !== "")
+    return [value.trim()];
+  if (!Array.isArray(value))
+    return [];
+  return value.filter((item) => typeof item === "string" && item.trim() !== "");
+}
 function isActiveTeamAgentStatus(status) {
   return status === "starting" || status === "running" || status === "busy" || status === "idle" || status === "waiting-input" || status === "recovering" || status === "recreated";
 }
@@ -9933,7 +10356,7 @@ async function handleUserPromptSubmit(input) {
   const previousBinding = await readSessionBinding(input.homeDir, input.rawPayload);
   const teamRuntimeContext = previousBinding?.teamRuntimeContextDeliveredAt === undefined || previousBinding.teamRuntimeContextDeliveredAt === null ? await createTeamRuntimeContextForUserPrompt(input) : null;
   const shouldShowDiagnostics = input.teamRuntimeDisplayMode === "development";
-  const teamRuntimeContextDeliveredAt = teamRuntimeContext !== null && shouldShowDiagnostics ? input.receivedAt ?? new Date().toISOString() : previousBinding?.teamRuntimeContextDeliveredAt ?? null;
+  const teamRuntimeContextDeliveredAt = teamRuntimeContext !== null ? input.receivedAt ?? new Date().toISOString() : previousBinding?.teamRuntimeContextDeliveredAt ?? null;
   const binding = {
     version: 1,
     target: input.target,
@@ -9955,7 +10378,7 @@ async function handleUserPromptSubmit(input) {
   let output = visibleContext === null || !shouldShowDiagnostics ? null : hookOutput(input.event.type, {
     additionalContext: visibleContext
   });
-  if (teamRuntimeContext !== null && shouldShowDiagnostics) {
+  if (teamRuntimeContext !== null) {
     output = appendAdditionalContext(output, input.event.type, teamRuntimeContext);
   }
   return createRuntimeResult(input, output, {
@@ -11250,14 +11673,14 @@ async function runDaemonForeground(input) {
       }));
     }
   });
-  await new Promise((resolve4, reject) => {
+  await new Promise((resolve5, reject) => {
     const onError = (error) => {
       server.off("listening", onListening);
       reject(error);
     };
     const onListening = () => {
       server.off("error", onError);
-      resolve4();
+      resolve5();
     };
     server.once("error", onError);
     server.once("listening", onListening);
@@ -11274,11 +11697,11 @@ async function runDaemonForeground(input) {
     processEvolutionTriggers({ homeDir: input.homeDir, limit: 20 }).then(() => clearDaemonEvolutionProcessError(input.homeDir)).catch((error) => recordDaemonEvolutionProcessError(input.homeDir, error));
   }, 5000);
   evolutionInterval.unref();
-  await new Promise((resolve4, reject) => {
+  await new Promise((resolve5, reject) => {
     server.once("close", () => {
       clearInterval(reconcileInterval);
       clearInterval(evolutionInterval);
-      resolve4();
+      resolve5();
     });
     server.once("error", reject);
   });
@@ -12214,7 +12637,7 @@ function isRecord10(value) {
 }
 // packages/core/src/pack/index.ts
 import { readFile as readFile14, readdir as readdir8, stat as stat10 } from "node:fs/promises";
-import { isAbsolute as isAbsolute5, join as join12, relative as relative6, sep } from "node:path";
+import { isAbsolute as isAbsolute6, join as join12, relative as relative7, sep } from "node:path";
 
 // packages/core/src/protected-zones/index.ts
 var SENSITIVE_DIRECTORY_SEGMENTS = new Set([
@@ -12698,7 +13121,7 @@ async function collectPackRelativePaths(packRoot, dir = packRoot) {
   const paths = [];
   for (const entry of entries) {
     const absolutePath = join12(dir, entry.name);
-    const relativePath = normalizeRelativePath(relative6(packRoot, absolutePath));
+    const relativePath = normalizeRelativePath(relative7(packRoot, absolutePath));
     paths.push(relativePath);
     if (entry.isDirectory()) {
       paths.push(...await collectPackRelativePaths(packRoot, absolutePath));
@@ -12713,7 +13136,7 @@ function validatePackRelativePath(path, packRoot) {
   if (path.includes("\x00")) {
     return { severity: "error", code: "path-invalid", message: "Path must not contain NUL bytes." };
   }
-  if (isAbsolute5(path) || path.startsWith("~")) {
+  if (isAbsolute6(path) || path.startsWith("~")) {
     return {
       severity: "error",
       code: "path-absolute",
@@ -12729,8 +13152,8 @@ function validatePackRelativePath(path, packRoot) {
     };
   }
   const absolute = join12(packRoot, normalized);
-  const rel = relative6(packRoot, absolute);
-  if (rel === "" || rel.startsWith("..") || isAbsolute5(rel)) {
+  const rel = relative7(packRoot, absolute);
+  if (rel === "" || rel.startsWith("..") || isAbsolute6(rel)) {
     return {
       severity: "error",
       code: "path-traversal",
@@ -13145,7 +13568,7 @@ function getEnabledPluginIds(settings) {
 }
 // packages/core/src/project/index.ts
 import { mkdir as mkdir13, readFile as readFile16, readdir as readdir9, stat as stat11, writeFile as writeFile12 } from "node:fs/promises";
-import { basename as basename5, join as join14, relative as relative7 } from "node:path";
+import { basename as basename5, join as join14, relative as relative8 } from "node:path";
 var PROJECT_CONTEXT_ALLOWED_RELATIVE_PATHS = [
   ".evodev/project.json",
   ".evodev/profile.md",
@@ -13352,7 +13775,7 @@ async function collectProjectFileMetadata(projectDir) {
     const entries = await readdir9(dir, { withFileTypes: true });
     for (const entry of entries) {
       const absolutePath = join14(dir, entry.name);
-      const relativePath = relative7(projectDir, absolutePath).replaceAll("\\", "/");
+      const relativePath = relative8(projectDir, absolutePath).replaceAll("\\", "/");
       if (shouldExcludePath(relativePath, entry.isDirectory())) {
         continue;
       }
@@ -14125,6 +14548,8 @@ export {
   resolveTraceSessionKey,
   resolveTeamRunPaths,
   resolveTeamRole,
+  resolveTeamOverlay,
+  resolveTeamAgentReference,
   resolveTaskContractOutputPath,
   resolveProjectLogKey,
   resolveOkfKnowledgePaths,
@@ -14140,10 +14565,14 @@ export {
   resolveContextInjectionReceiptPath,
   resolveCodexCapabilityArtifactPath,
   resolveCodeAgentTraceRefPaths,
+  renderRoleAgentDefinitionContext,
+  renderMainTeamOverlayContext,
   recordTeamAgentNativeSession,
   recordCodeAgentTraceRefFromHook,
   reconcileTeamRun,
   rebuildOkfKnowledgeIndexes,
+  readTeamAgentSummary,
+  readTeamAgentDefinition,
   readTaskContract,
   readRuntimeInjectionSettings,
   readPendingTeamMessagesForRole,
@@ -14168,6 +14597,7 @@ export {
   pathExists8 as pathExists,
   parseWorkflowManifest,
   parseTeamRoleDefinition,
+  parseTeamDefinitionMarkdown,
   parseSyncState,
   parseSkillManifest,
   parseSettings,
@@ -14250,6 +14680,7 @@ export {
   formatAgentComposeDryRun,
   findCandidateConflictOrDuplicate,
   ensureOkfKnowledgeBase,
+  ensureDefaultTeamOverlay,
   enqueueEvolutionTrigger,
   dryRunObservabilityRetentionCleanup,
   discardFailedOkfKnowledgePlan,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@evo-dev/core",
-  "version": "0.0.1-alpha.2",
+  "version": "0.0.1-alpha.3",
   "type": "module",
   "repository": {
     "type": "git",

package/src/hooks/index.ts

@@ -790,7 +790,7 @@ async function handleUserPromptSubmit(input: HandleHookRuntimeInput): Promise<Ho
       : null;
   const shouldShowDiagnostics = input.teamRuntimeDisplayMode === "development";
   const teamRuntimeContextDeliveredAt =
-    teamRuntimeContext !== null && shouldShowDiagnostics
+    teamRuntimeContext !== null
       ? (input.receivedAt ?? new Date().toISOString())
       : (previousBinding?.teamRuntimeContextDeliveredAt ?? null);
   const binding: HookRuntimeSessionBinding = {
@@ -819,7 +819,7 @@ async function handleUserPromptSubmit(input: HandleHookRuntimeInput): Promise<Ho
       : hookOutput(input.event.type, {
           additionalContext: visibleContext,
         });
-  if (teamRuntimeContext !== null && shouldShowDiagnostics) {
+  if (teamRuntimeContext !== null) {
     output = appendAdditionalContext(output, input.event.type, teamRuntimeContext);
   }