@evo-dev/core 0.0.1-alpha.19 → 0.0.1-alpha.20

package/src/hooks/index.ts

@@ -8,13 +8,14 @@ import {
   createScopedKnowledgeContextPack,
   formatScopedKnowledgePromptBlock,
   hasContextInjectionReceipt,
+  recordContextInjectionOutcome,
   writeContextInjectionReceipt,
 } from "../evolution/knowledge/index.ts";
 import {
   enqueueEvolutionTrigger,
   resolveEvolutionTriggerDecision,
 } from "../evolution/triggers/index.ts";
-import { recordDiscoveredProject } from "../projects/index.ts";
+import { recordDiscoveredProject, resolveProjectWorkspaceFromCwd } from "../projects/index.ts";
 import { resolveTraceSessionKey, resolveTraceTeamContext } from "../runtime-logs/index.ts";
 import {
   type TeamMessageRecord,
@@ -156,6 +157,7 @@ export interface HookRuntimeSessionBinding {
   sessionKey: string;
   cwd: string | null;
   teamRuntimeContextDeliveredAt?: string | null;
+  knowledgeContextDeliveredAt?: string | null;
   updatedAt: string;
 }
 
@@ -488,26 +490,20 @@ export async function handleHookRuntime(input: HandleHookRuntimeInput): Promise<
       : await recordEvolutionTriggerFromHook(input);
   const messageDiagnostics = await deliverPendingTeamMessagesFromHook(input, result);
   const scopedContextDiagnostics = await injectScopedKnowledgeContextFromHook(input, result);
+  const knowledgeOutcomeDiagnostics = await recordKnowledgeOutcomeFromHook(input);
   const teamStateDiagnostics = await recordTeamAgentHookStateFromHook(input);
-  const completed = appendRuntimeDiagnostics(
-    appendRuntimeDiagnostics(
-      appendRuntimeDiagnostics(
-        appendRuntimeDiagnostics(
-          appendRuntimeDiagnostics(
-            appendRuntimeDiagnostics(
-              appendRuntimeDiagnostics(result, diagnostics),
-              projectDiagnostics,
-            ),
-            sessionMemoryDiagnostics,
-          ),
-          evolutionDiagnostics,
-        ),
-        messageDiagnostics,
-      ),
-      scopedContextDiagnostics,
-    ),
+  let completed = appendRuntimeDiagnostics(result, diagnostics);
+  for (const entry of [
+    projectDiagnostics,
+    sessionMemoryDiagnostics,
+    evolutionDiagnostics,
+    messageDiagnostics,
+    scopedContextDiagnostics,
+    knowledgeOutcomeDiagnostics,
     teamStateDiagnostics,
-  );
+  ]) {
+    completed = appendRuntimeDiagnostics(completed, entry);
+  }
   return appendDevelopmentHookDiagnostics(input, completed);
 }
 
@@ -765,7 +761,8 @@ async function injectScopedKnowledgeContextFromHook(
     environment: input.environment,
     payload: input.rawPayload,
   });
-  if (team === null || team.roleId !== "main") return { stateWrites: [], warnings: [] };
+  if (team === null) return injectOrdinarySessionKnowledge(input, result);
+  if (team.roleId !== "main") return { stateWrites: [], warnings: [] };
 
   try {
     if (input.runtimeInjectionEnabled === false) return { stateWrites: [], warnings: [] };
@@ -807,6 +804,112 @@ async function injectScopedKnowledgeContextFromHook(
   }
 }
 
+async function injectOrdinarySessionKnowledge(
+  input: HandleHookRuntimeInput,
+  result: HookRuntimeResult,
+): Promise<HookRuntimeDiagnostics> {
+  if (input.event.type !== "UserPromptSubmit" || input.runtimeInjectionEnabled === false) {
+    return { stateWrites: [], warnings: [] };
+  }
+  const cwd = optionalPayloadString(input.rawPayload.cwd);
+  if (cwd === null) return { stateWrites: [], warnings: [] };
+  const sessionKey = resolveHookSessionKey(input.rawPayload);
+  const paths = resolveHookRuntimeSessionPaths({ homeDir: input.homeDir, sessionKey });
+  const binding = await readSessionBinding(input.homeDir, input.rawPayload);
+  if (
+    binding?.knowledgeContextDeliveredAt !== undefined &&
+    binding.knowledgeContextDeliveredAt !== null
+  ) {
+    return { stateWrites: [], warnings: [] };
+  }
+
+  try {
+    const workspace = await resolveProjectWorkspaceFromCwd({ homeDir: input.homeDir, cwd });
+    if (workspace === null) return { stateWrites: [], warnings: [] };
+    const queryText = readKnowledgeQueryText(input.rawPayload);
+    const pack = await createScopedKnowledgeContextPack({
+      homeDir: input.homeDir,
+      projectKey: workspace.projectKey,
+      roleId: input.target,
+      ...(queryText === null ? {} : { queryText }),
+      limit: 3,
+      inlineOnly: true,
+    });
+    const deliveredAt = input.receivedAt ?? new Date().toISOString();
+    const nextBinding: HookRuntimeSessionBinding = {
+      version: 1,
+      target: input.target,
+      sessionKey,
+      cwd,
+      teamRuntimeContextDeliveredAt: binding?.teamRuntimeContextDeliveredAt ?? null,
+      knowledgeContextDeliveredAt: deliveredAt,
+      updatedAt: deliveredAt,
+    };
+    await writeJsonFile(paths.bindingPath, nextBinding);
+    if (pack === null) return { stateWrites: [paths.bindingPath], warnings: [] };
+    const receipt = await writeContextInjectionReceipt({
+      homeDir: input.homeDir,
+      sessionKey,
+      pack,
+      trigger: "ordinary-session",
+      hookEventId: input.event.eventId,
+      injectedAt: deliveredAt,
+    });
+    result.output = appendAdditionalContext(
+      result.output,
+      input.event.type,
+      formatScopedKnowledgePromptBlock(pack),
+    );
+    return { stateWrites: [paths.bindingPath, receipt.path], warnings: [] };
+  } catch {
+    return {
+      stateWrites: [],
+      warnings: ["Ordinary-session knowledge context could not be injected."],
+    };
+  }
+}
+
+function readKnowledgeQueryText(payload: Record<string, unknown>): string | null {
+  for (const value of [
+    payload.prompt,
+    payload.user_prompt,
+    payload.userPrompt,
+    payload.query,
+    payload.message,
+    payload.text,
+  ]) {
+    if (typeof value === "string" && value.trim() !== "") return value.trim().slice(0, 4_000);
+  }
+  return null;
+}
+
+async function recordKnowledgeOutcomeFromHook(
+  input: HandleHookRuntimeInput,
+): Promise<HookRuntimeDiagnostics> {
+  if (!isKnowledgeOutcomeSignal(input.event)) return { stateWrites: [], warnings: [] };
+  try {
+    const paths = await recordContextInjectionOutcome({
+      homeDir: input.homeDir,
+      sessionKey: resolveHookSessionKey(input.rawPayload),
+      eventId: input.event.eventId,
+      observedAt: input.receivedAt ?? input.event.time.receivedAt ?? new Date().toISOString(),
+      summary: input.event.payload.summary,
+    });
+    return { stateWrites: paths, warnings: [] };
+  } catch {
+    return {
+      stateWrites: [],
+      warnings: ["Knowledge delivery outcome metadata could not be recorded."],
+    };
+  }
+}
+
+function isKnowledgeOutcomeSignal(event: HookEventV1): boolean {
+  if (event.type !== "PostToolUse") return false;
+  if (event.payload.metadata.commandClass === "test-command") return true;
+  return /\b(?:test|lint|typecheck|build|verify|check)\b/iu.test(event.payload.summary);
+}
+
 function canDeliverTeamMessagesFromHook(
   target: CodeAgentHookTarget,
   eventType: CanonicalHookEventType,
@@ -886,6 +989,7 @@ async function handleUserPromptSubmit(input: HandleHookRuntimeInput): Promise<Ho
     sessionKey,
     cwd: optionalPayloadString(input.rawPayload.cwd),
     teamRuntimeContextDeliveredAt,
+    knowledgeContextDeliveredAt: previousBinding?.knowledgeContextDeliveredAt ?? null,
     updatedAt: input.receivedAt ?? new Date().toISOString(),
   };