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

package/src/hooks/index.ts

@@ -2,6 +2,12 @@ import { createHash } from "node:crypto";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { enqueueEvolutionTrigger, resolveEvolutionTriggerDecision } from "../evolution/index.ts";
+import {
+  createScopedKnowledgeContextPack,
+  formatScopedKnowledgePromptBlock,
+  hasContextInjectionReceipt,
+  writeContextInjectionReceipt,
+} from "../knowledge/index.ts";
 import { resolveTraceTeamContext } from "../runtime-logs/index.ts";
 import {
   type TaskContract,
@@ -9,7 +15,15 @@ import {
   routeTaskContract,
   writeTaskContract,
 } from "../task/index.ts";
-import { recordTeamAgentNativeSession, resolveTeamRunPaths } from "../team/index.ts";
+import {
+  type TeamMessageRecord,
+  createTeamRoleRuntimeContext,
+  markTeamMessagesDelivered,
+  readPendingTeamMessagesForRole,
+  recordTeamAgentNativeSession,
+  resolveTeamRunPaths,
+  updateTeamAgentHookState,
+} from "../team/index.ts";
 
 export const CANONICAL_HOOK_EVENT_TYPES = [
   "SessionStart",
@@ -142,6 +156,7 @@ export interface HookRuntimeSessionBinding {
   contractPath: string | null;
   cwd: string | null;
   route: TaskContract["route"] | null;
+  teamRuntimeContextDeliveredAt?: string | null;
   updatedAt: string;
 }
 
@@ -159,10 +174,12 @@ export interface HandleHookRuntimeInput {
   target: CodeAgentHookTarget;
   homeDir: string;
   settings: HookSettings;
+  teamRuntimeDisplayMode?: "normal" | "development";
   event: HookEventV1;
   rawPayload: Record<string, unknown>;
   receivedAt?: string;
   environment?: Record<string, string | undefined>;
+  runtimeInjectionEnabled?: boolean;
 }
 
 const DEFAULT_EVENT_SETTINGS: Record<CanonicalHookEventType, boolean> = {
@@ -195,6 +212,20 @@ const DEFAULT_EVENT_SETTINGS: Record<CanonicalHookEventType, boolean> = {
 const SENSITIVE_TEXT_PATTERN =
   /https?:\/\/\S+|\b(secret|token|password|passwd|private|internal|api[_-]?key|apikey|credential|credentials|\.env)\b/i;
 const SOURCE_LIKE_PATTERN = /\b(function|class|import|export|const|let|var)\b.*[{};]/s;
+const TEAM_MESSAGE_DELIVERY_EVENTS = new Set<CanonicalHookEventType>([
+  "SessionStart",
+  "UserPromptSubmit",
+  "PostToolUse",
+  "PostToolUseFailure",
+  "Stop",
+  "TeammateIdle",
+  "SubagentStop",
+  "TaskCompleted",
+]);
+const CODEX_STOP_EVENTS_WITHOUT_ADDITIONAL_CONTEXT = new Set<CanonicalHookEventType>([
+  "Stop",
+  "SubagentStop",
+]);
 
 export function createDefaultHookSettings(): HookSettings {
   return {
@@ -210,8 +241,8 @@ export function createDefaultHookSettings(): HookSettings {
       },
     },
     observability: {
-      metadataOnly: false,
-      rawPayloadStorage: true,
+      metadataOnly: true,
+      rawPayloadStorage: false,
       appendEvents: false,
     },
     learning: {
@@ -244,8 +275,8 @@ export function parseHookSettings(value: unknown): HookSettings {
       codex: parseHookTargetSettings(value.targets, defaults.targets.codex, "codex"),
     },
     observability: {
-      metadataOnly: false,
-      rawPayloadStorage: true,
+      metadataOnly: true,
+      rawPayloadStorage: false,
       appendEvents: optionalBoolean(
         observability?.appendEvents,
         defaults.observability.appendEvents,
@@ -277,7 +308,7 @@ export function normalizeHookEvent(input: NormalizeHookEventInput): HookEventV1
       pluginId: sanitizeScalar(input.pluginId, redactions),
       agent: sanitizeScalar(input.agent ?? "unknown", redactions),
       sessionIdHash,
-      rawPayloadStored: true,
+      rawPayloadStored: false,
     },
     time: {
       occurredAt: optionalSanitizedString(
@@ -289,7 +320,7 @@ export function normalizeHookEvent(input: NormalizeHookEventInput): HookEventV1
     scope: {
       taskId: optionalSanitizedString(input.payload.taskId, redactions),
       projectId: optionalSanitizedString(input.payload.projectId, redactions),
-      cwdPolicy: "raw-local",
+      cwdPolicy: "metadata-only",
       projectContextOptedIn: false,
     },
     payload: {
@@ -297,7 +328,7 @@ export function normalizeHookEvent(input: NormalizeHookEventInput): HookEventV1
       metadata,
       redactions,
       redactionCount: redactions.length,
-      rawContentIncluded: true,
+      rawContentIncluded: false,
     },
     policy: {
       classification: "local-private",
@@ -338,8 +369,8 @@ export function formatHookInstallDryRun(plan: HookInstallDryRunPlan): string {
       (eventType) => `  - ${eventType}: ${plan.settings.targets[plan.target].events[eventType]}`,
     ),
     "Boundaries:",
-    "  - trace: local raw payload storage=required, external upload=false",
-    "  - derived evidence/knowledge/observability surfaces: metadata-only until review/export",
+    "  - execution events: metadata-only; raw payload/prompt/output/source storage=false",
+    "  - historical raw trace files may remain for read-only migration compatibility",
     "  - learning: emitCandidates=false, writeMemory=false",
     "  - external upload: false",
     "  - protected project writes: .claude/.codex/CLAUDE.md/AGENTS.md not targeted",
@@ -438,9 +469,21 @@ export async function handleHookRuntime(input: HandleHookRuntimeInput): Promise<
     result = await handleAdditionalContext(input, input.event.type);
   }
   const evolutionDiagnostics = await recordEvolutionTriggerFromHook(input);
+  const messageDiagnostics = await deliverPendingTeamMessagesFromHook(input, result);
+  const scopedContextDiagnostics = await injectScopedKnowledgeContextFromHook(input, result);
+  const teamStateDiagnostics = await recordTeamAgentHookStateFromHook(input);
   return appendRuntimeDiagnostics(
-    appendRuntimeDiagnostics(result, diagnostics),
-    evolutionDiagnostics,
+    appendRuntimeDiagnostics(
+      appendRuntimeDiagnostics(
+        appendRuntimeDiagnostics(
+          appendRuntimeDiagnostics(result, diagnostics),
+          evolutionDiagnostics,
+        ),
+        messageDiagnostics,
+      ),
+      scopedContextDiagnostics,
+    ),
+    teamStateDiagnostics,
   );
 }
 
@@ -568,6 +611,152 @@ async function recordEvolutionTriggerFromHook(
   }
 }
 
+async function deliverPendingTeamMessagesFromHook(
+  input: HandleHookRuntimeInput,
+  result: HookRuntimeResult | undefined,
+): Promise<HookRuntimeDiagnostics> {
+  if (result === undefined || !canDeliverTeamMessagesFromHook(input.target, input.event.type)) {
+    return { stateWrites: [], warnings: [] };
+  }
+  const team = resolveTraceTeamContext({
+    homeDir: input.homeDir,
+    environment: input.environment,
+    payload: input.rawPayload,
+  });
+  if (team === null) return { stateWrites: [], warnings: [] };
+
+  try {
+    const messages = await readPendingTeamMessagesForRole({
+      homeDir: input.homeDir,
+      runId: team.runId,
+      roleId: team.roleId,
+      limit: 5,
+    });
+    if (messages.length === 0) return { stateWrites: [], warnings: [] };
+    result.output = appendAdditionalContext(
+      result.output,
+      input.event.type,
+      formatTeamInboxContext(messages),
+    );
+    await markTeamMessagesDelivered({
+      homeDir: input.homeDir,
+      runId: team.runId,
+      roleId: team.roleId,
+      messageIds: messages.map((message) => message.messageId),
+      now:
+        input.receivedAt === undefined || input.receivedAt === "dry-run"
+          ? undefined
+          : new Date(input.receivedAt),
+    });
+    const teamPaths = resolveTeamRunPaths(input.homeDir);
+    return {
+      stateWrites: [teamPaths.eventsPath(team.runId), teamPaths.messageListPath(team.runId)],
+      warnings: [],
+    };
+  } catch {
+    return {
+      stateWrites: [],
+      warnings: [
+        `Team inbox messages could not be delivered for role ${safeDiagnosticId(team.roleId)}.`,
+      ],
+    };
+  }
+}
+
+async function injectScopedKnowledgeContextFromHook(
+  input: HandleHookRuntimeInput,
+  result: HookRuntimeResult | undefined,
+): Promise<HookRuntimeDiagnostics> {
+  if (result === undefined || !canDeliverTeamMessagesFromHook(input.target, input.event.type)) {
+    return { stateWrites: [], warnings: [] };
+  }
+  const team = resolveTraceTeamContext({
+    homeDir: input.homeDir,
+    environment: input.environment,
+    payload: input.rawPayload,
+  });
+  if (team === null || team.roleId !== "main") return { stateWrites: [], warnings: [] };
+
+  try {
+    if (input.runtimeInjectionEnabled === false) return { stateWrites: [], warnings: [] };
+    const pack = await createScopedKnowledgeContextPack({
+      homeDir: input.homeDir,
+      projectKey: team.projectKey,
+      roleId: team.roleId,
+    });
+    if (pack === null) return { stateWrites: [], warnings: [] };
+    const sessionKey = resolveHookSessionKey(input.rawPayload);
+    if (
+      await hasContextInjectionReceipt({
+        homeDir: input.homeDir,
+        sessionKey,
+        contextPackId: pack.id,
+      })
+    ) {
+      return { stateWrites: [], warnings: [] };
+    }
+    const receipt = await writeContextInjectionReceipt({
+      homeDir: input.homeDir,
+      sessionKey,
+      pack,
+      trigger: "hook-safe-point",
+      hookEventId: input.event.eventId,
+      injectedAt: input.receivedAt ?? new Date().toISOString(),
+    });
+    result.output = appendAdditionalContext(
+      result.output,
+      input.event.type,
+      formatScopedKnowledgePromptBlock(pack),
+    );
+    return { stateWrites: [receipt.path], warnings: [] };
+  } catch {
+    return {
+      stateWrites: [],
+      warnings: ["Scoped knowledge context could not be injected at this hook safe point."],
+    };
+  }
+}
+
+function canDeliverTeamMessagesFromHook(
+  target: CodeAgentHookTarget,
+  eventType: CanonicalHookEventType,
+): boolean {
+  if (!TEAM_MESSAGE_DELIVERY_EVENTS.has(eventType)) return false;
+  return target !== "codex" || !CODEX_STOP_EVENTS_WITHOUT_ADDITIONAL_CONTEXT.has(eventType);
+}
+
+async function recordTeamAgentHookStateFromHook(
+  input: HandleHookRuntimeInput,
+): Promise<HookRuntimeDiagnostics> {
+  const team = resolveTraceTeamContext({
+    homeDir: input.homeDir,
+    environment: input.environment,
+    payload: input.rawPayload,
+  });
+  if (team === null) return { stateWrites: [], warnings: [] };
+
+  try {
+    const result = await updateTeamAgentHookState({
+      homeDir: input.homeDir,
+      runId: team.runId,
+      roleId: team.roleId,
+      hookEvent: input.event.type,
+      now:
+        input.receivedAt === undefined || input.receivedAt === "dry-run"
+          ? undefined
+          : new Date(input.receivedAt),
+    });
+    return { stateWrites: [result.agentPath, result.statusPath], warnings: [] };
+  } catch {
+    return {
+      stateWrites: [],
+      warnings: [
+        `Team agent state could not be updated for hook role ${safeDiagnosticId(team.roleId)}.`,
+      ],
+    };
+  }
+}
+
 function appendRuntimeDiagnostics(
   result: HookRuntimeResult | undefined,
   diagnostics: HookRuntimeDiagnostics,
@@ -583,15 +772,7 @@ function appendRuntimeDiagnostics(
 }
 
 async function handleSessionStart(input: HandleHookRuntimeInput): Promise<HookRuntimeResult> {
-  const binding = await readSessionBinding(input.homeDir, input.rawPayload);
-  const context = [
-    "EvoDev session initialized.",
-    binding?.contractPath
-      ? `Active Task Contract: ${binding.contractPath}`
-      : "No active Task Contract yet.",
-    "User prompts will be routed through EvoDev before execution.",
-  ].join(" ");
-  return createRuntimeResult(input, hookOutput(input.event.type, { additionalContext: context }), {
+  return createRuntimeResult(input, null, {
     summary: "Session context prepared.",
   });
 }
@@ -601,6 +782,17 @@ async function handleUserPromptSubmit(input: HandleHookRuntimeInput): Promise<Ho
   const sessionKey = resolveHookSessionKey(input.rawPayload);
   const paths = resolveHookRuntimeSessionPaths({ homeDir: input.homeDir, sessionKey });
   const contract = routeTaskContract(createHookTaskContract(input, classification));
+  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 binding: HookRuntimeSessionBinding = {
     version: 1,
     target: input.target,
@@ -609,28 +801,55 @@ async function handleUserPromptSubmit(input: HandleHookRuntimeInput): Promise<Ho
     contractPath: paths.contractPath,
     cwd: optionalPayloadString(input.rawPayload.cwd),
     route: contract.route,
+    teamRuntimeContextDeliveredAt,
     updatedAt: input.receivedAt ?? new Date().toISOString(),
   };
 
   await writeTaskContract(paths.contractPath, contract, { overwrite: true });
   await writeJsonFile(paths.bindingPath, binding);
 
-  const context = [
-    `EvoDev observed this request before ${formatHookTargetName(input.target)} execution.`,
-    "Advisory only: EvoDev does not grant, deny, or stop model/tool execution.",
-    `Task Contract: ${paths.contractPath}`,
-    `Suggested mode: ${contract.route.mode ?? "unknown"}`,
-    `Suggested workflow: ${contract.route.workflowId ?? "none"}`,
-    `Reason: ${contract.route.rationale}`,
-    "Use the suggestion only if it fits the user request.",
-  ].join(" ");
+  const visibleContext = createUserPromptVisibleContext({
+    classification,
+    contract,
+    contractPath: paths.contractPath,
+  });
+  let output =
+    visibleContext === null || !shouldShowDiagnostics
+      ? null
+      : hookOutput(input.event.type, {
+          additionalContext: visibleContext,
+        });
+  if (teamRuntimeContext !== null && shouldShowDiagnostics) {
+    output = appendAdditionalContext(output, input.event.type, teamRuntimeContext);
+  }
 
-  return createRuntimeResult(input, hookOutput(input.event.type, { additionalContext: context }), {
-    summary: "User prompt observed and advisory context prepared.",
+  return createRuntimeResult(input, output, {
+    summary: "User prompt observed; Task Contract prepared.",
     stateWrites: [paths.contractPath, paths.bindingPath],
   });
 }
 
+async function createTeamRuntimeContextForUserPrompt(
+  input: HandleHookRuntimeInput,
+): Promise<string | null> {
+  const team = resolveTraceTeamContext({
+    homeDir: input.homeDir,
+    environment: input.environment,
+    payload: input.rawPayload,
+  });
+  if (team === null || team.roleId !== "main") return null;
+
+  try {
+    return await createTeamRoleRuntimeContext({
+      homeDir: input.homeDir,
+      runId: team.runId,
+      roleId: team.roleId,
+    });
+  } catch {
+    return null;
+  }
+}
+
 async function handlePreToolUse(input: HandleHookRuntimeInput): Promise<HookRuntimeResult> {
   const commandClass =
     typeof input.event.payload.metadata.commandClass === "string"
@@ -748,6 +967,68 @@ function hookOutput(
   };
 }
 
+function appendAdditionalContext(
+  output: Record<string, unknown> | null,
+  eventName: CanonicalHookEventType,
+  context: string,
+): Record<string, unknown> {
+  if (output === null) return hookOutput(eventName, { additionalContext: context });
+  const hookSpecificOutput = isRecord(output.hookSpecificOutput) ? output.hookSpecificOutput : {};
+  const previous =
+    typeof hookSpecificOutput.additionalContext === "string"
+      ? hookSpecificOutput.additionalContext
+      : "";
+  return {
+    ...output,
+    hookSpecificOutput: {
+      ...hookSpecificOutput,
+      hookEventName:
+        typeof hookSpecificOutput.hookEventName === "string"
+          ? hookSpecificOutput.hookEventName
+          : eventName,
+      additionalContext: previous === "" ? context : `${previous}\n\n${context}`,
+    },
+  };
+}
+
+function formatTeamInboxContext(messages: TeamMessageRecord[]): string {
+  const blocks = messages.map((message) =>
+    [
+      "[EvoDev team message]",
+      "Instruction: read this queued team message at this safe point; reply through Teams MCP only when a response is needed.",
+      `from: ${message.fromRoleId}`,
+      `to: ${message.toRoleId}`,
+      `type: ${message.type}`,
+      `messageId: ${message.messageId}`,
+      `cc: ${message.ccRoleIds.join(",") || "none"}`,
+      "",
+      truncateTeamMessageBody(message.body),
+      "[/EvoDev team message]",
+    ].join("\n"),
+  );
+  return ["EvoDev team inbox:", ...blocks].join("\n\n");
+}
+
+function truncateTeamMessageBody(value: string): string {
+  if (value.length <= 4000) return value;
+  return `${value.slice(0, 4000)}...[truncated:${value.length - 4000}]`;
+}
+
+function createUserPromptVisibleContext(input: {
+  classification: ReturnType<typeof classifyUserPrompt>;
+  contract: TaskContract;
+  contractPath: string;
+}): string | null {
+  if (!input.classification.needsClarification) return null;
+  return [
+    "EvoDev advisory: clarification may be needed before broad changes.",
+    `Task Contract: ${input.contractPath}`,
+    `Suggested mode: ${input.contract.route.mode ?? "unknown"}`,
+    `Suggested workflow: ${input.contract.route.workflowId ?? "none"}`,
+    `Reason: ${input.contract.route.rationale}`,
+  ].join(" ");
+}
+
 function createHookTaskContract(
   input: HandleHookRuntimeInput,
   classification: ReturnType<typeof classifyUserPrompt>,
@@ -756,7 +1037,7 @@ function createHookTaskContract(
   const targetName = formatHookTargetName(input.target);
   const contract = createTaskContract({
     title: `${targetName} hook task ${sessionKey}`,
-    summary: `${targetName} prompt classified as ${classification.kind}; raw prompt is local trace only.`,
+    summary: `${targetName} prompt classified as ${classification.kind}; raw prompt is not stored by EvoDev.`,
     projectId: null,
   });
 
@@ -927,9 +1208,7 @@ function extractMetadata(
   payload: Record<string, unknown>,
   redactions: string[],
 ): Record<string, string | number | boolean | string[]> {
-  const metadata: Record<string, string | number | boolean | string[]> = {
-    rawContentIncluded: true,
-  };
+  const metadata: Record<string, string | number | boolean | string[]> = {};
   const toolInput = isRecord(payload.tool_input)
     ? payload.tool_input
     : isRecord(payload.toolInput)

package/src/index.ts

@@ -1,9 +1,11 @@
 export * from "./agents/index.ts";
 export * from "./assets/index.ts";
+export * from "./code-agent-traces/index.ts";
 export * from "./config/index.ts";
 export * from "./daemon/index.ts";
 export * from "./evolution/index.ts";
 export * from "./hooks/index.ts";
+export * from "./knowledge/index.ts";
 export * from "./learning/index.ts";
 export * from "./observability/index.ts";
 export * from "./pack/index.ts";