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

package/src/hooks/index.ts

@@ -1,20 +1,22 @@
-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 {
+  type SessionMemoryPolicySnapshot,
+  updateSessionMemoryFromHook,
+} from "../evolution/evidence/session-memory/index.ts";
 import {
   createScopedKnowledgeContextPack,
   formatScopedKnowledgePromptBlock,
   hasContextInjectionReceipt,
+  recordContextInjectionOutcome,
   writeContextInjectionReceipt,
-} from "../knowledge/index.ts";
-import { resolveTraceTeamContext } from "../runtime-logs/index.ts";
+} from "../evolution/knowledge/index.ts";
 import {
-  type TaskContract,
-  createTaskContract,
-  routeTaskContract,
-  writeTaskContract,
-} from "../task/index.ts";
+  enqueueEvolutionTrigger,
+  resolveEvolutionTriggerDecision,
+} from "../evolution/triggers/index.ts";
+import { recordDiscoveredProject, resolveProjectWorkspaceFromCwd } from "../projects/index.ts";
+import { resolveTraceSessionKey, resolveTraceTeamContext } from "../runtime-logs/index.ts";
 import {
   type TeamMessageRecord,
   createTeamRoleRuntimeContext,
@@ -24,6 +26,7 @@ import {
   resolveTeamRunPaths,
   updateTeamAgentHookState,
 } from "../team/index.ts";
+import { sha256Short } from "../utils/index.ts";
 
 export const CANONICAL_HOOK_EVENT_TYPES = [
   "SessionStart",
@@ -152,11 +155,9 @@ export interface HookRuntimeSessionBinding {
   version: 1;
   target: CodeAgentHookTarget;
   sessionKey: string;
-  taskId: string | null;
-  contractPath: string | null;
   cwd: string | null;
-  route: TaskContract["route"] | null;
   teamRuntimeContextDeliveredAt?: string | null;
+  knowledgeContextDeliveredAt?: string | null;
   updatedAt: string;
 }
 
@@ -180,6 +181,7 @@ export interface HandleHookRuntimeInput {
   receivedAt?: string;
   environment?: Record<string, string | undefined>;
   runtimeInjectionEnabled?: boolean;
+  sessionMemoryPolicy?: Partial<SessionMemoryPolicySnapshot>;
 }
 
 const DEFAULT_EVENT_SETTINGS: Record<CanonicalHookEventType, boolean> = {
@@ -226,6 +228,12 @@ const CODEX_STOP_EVENTS_WITHOUT_ADDITIONAL_CONTEXT = new Set<CanonicalHookEventT
   "Stop",
   "SubagentStop",
 ]);
+const COMPLETION_EVENTS_WITHOUT_DEVELOPMENT_DIAGNOSTICS = new Set<CanonicalHookEventType>([
+  "Stop",
+  "SubagentStop",
+  "TaskCompleted",
+  "TeammateIdle",
+]);
 
 export function createDefaultHookSettings(): HookSettings {
   return {
@@ -416,12 +424,11 @@ export function formatHookEventDryRun(event: HookEventV1): string {
 export function resolveHookRuntimeSessionPaths(input: {
   homeDir: string;
   sessionKey: string;
-}): { sessionDir: string; bindingPath: string; contractPath: string } {
+}): { sessionDir: string; bindingPath: string } {
   const sessionDir = join(input.homeDir, ".evodev", "STATE", "hooks", "sessions", input.sessionKey);
   return {
     sessionDir,
     bindingPath: join(sessionDir, "binding.json"),
-    contractPath: join(sessionDir, "contract.json"),
   };
 }
 
@@ -439,7 +446,14 @@ export async function handleHookRuntime(input: HandleHookRuntimeInput): Promise<
     };
   }
 
+  if (isActiveClaudeStopHook(input)) {
+    return createRuntimeResult(input, null, {
+      summary: `${input.event.type} re-entry allowed to complete without hook output.`,
+    });
+  }
+
   const diagnostics = await recordTeamNativeSessionFromHook(input);
+  const projectDiagnostics = await recordDiscoveredProjectFromHook(input);
   let result: HookRuntimeResult | undefined;
   if (input.event.type === "SessionStart") result = await handleSessionStart(input);
   else if (input.event.type === "UserPromptSubmit") result = await handleUserPromptSubmit(input);
@@ -468,23 +482,29 @@ export async function handleHookRuntime(input: HandleHookRuntimeInput): Promise<
   } else if (result === undefined) {
     result = await handleAdditionalContext(input, input.event.type);
   }
-  const evolutionDiagnostics = await recordEvolutionTriggerFromHook(input);
+  const sessionMemoryDiagnostics = await recordSessionMemoryFromHook(input);
+  const evolutionDiagnostics =
+    sessionMemoryDiagnostics.queuedSegmentTriggerId !== null ||
+    shouldSuppressLegacyEvolutionTrigger(input.event.type)
+      ? { stateWrites: [], warnings: [] }
+      : 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);
-  return appendRuntimeDiagnostics(
-    appendRuntimeDiagnostics(
-      appendRuntimeDiagnostics(
-        appendRuntimeDiagnostics(
-          appendRuntimeDiagnostics(result, diagnostics),
-          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);
 }
 
 export function formatHookRuntimeOutput(result: HookRuntimeResult): string {
@@ -508,6 +528,41 @@ interface HookRuntimeDiagnostics {
   warnings: string[];
 }
 
+async function recordDiscoveredProjectFromHook(
+  input: HandleHookRuntimeInput,
+): Promise<HookRuntimeDiagnostics> {
+  if (
+    input.event.type !== "SessionStart" &&
+    input.event.type !== "UserPromptSubmit" &&
+    input.event.type !== "CwdChanged"
+  ) {
+    return { stateWrites: [], warnings: [] };
+  }
+  const cwd = optionalPayloadString(input.rawPayload.cwd);
+  if (cwd === null) return { stateWrites: [], warnings: [] };
+
+  try {
+    const result = await recordDiscoveredProject({
+      homeDir: input.homeDir,
+      cwd,
+      target: input.target,
+      sessionKey: resolveTraceSessionKey(input.rawPayload),
+      now:
+        input.receivedAt === undefined || input.receivedAt === "dry-run"
+          ? undefined
+          : input.receivedAt,
+    });
+    return result === null
+      ? { stateWrites: [], warnings: [] }
+      : { stateWrites: [result.path], warnings: [] };
+  } catch {
+    return {
+      stateWrites: [],
+      warnings: ["Local project discovery could not be updated at this hook safe point."],
+    };
+  }
+}
+
 async function recordTeamNativeSessionFromHook(
   input: HandleHookRuntimeInput,
 ): Promise<HookRuntimeDiagnostics> {
@@ -611,6 +666,37 @@ async function recordEvolutionTriggerFromHook(
   }
 }
 
+async function recordSessionMemoryFromHook(
+  input: HandleHookRuntimeInput,
+): Promise<HookRuntimeDiagnostics & { queuedSegmentTriggerId: string | null }> {
+  try {
+    const result = await updateSessionMemoryFromHook({
+      homeDir: input.homeDir,
+      target: input.target,
+      event: input.event,
+      rawPayload: input.rawPayload,
+      environment: input.environment,
+      receivedAt: input.receivedAt,
+      policy: input.sessionMemoryPolicy,
+    });
+    return {
+      stateWrites: result.stateWrites,
+      warnings: result.warnings,
+      queuedSegmentTriggerId: result.queuedSegmentTriggerId,
+    };
+  } catch {
+    return {
+      stateWrites: [],
+      warnings: ["Session Memory state could not be updated at this hook safe point."],
+      queuedSegmentTriggerId: null,
+    };
+  }
+}
+
+function shouldSuppressLegacyEvolutionTrigger(eventType: CanonicalHookEventType): boolean {
+  return eventType === "Stop" || eventType === "SubagentStop" || eventType === "SessionEnd";
+}
+
 async function deliverPendingTeamMessagesFromHook(
   input: HandleHookRuntimeInput,
   result: HookRuntimeResult | undefined,
@@ -675,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: [] };
@@ -717,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,
@@ -778,54 +971,38 @@ async function handleSessionStart(input: HandleHookRuntimeInput): Promise<HookRu
 }
 
 async function handleUserPromptSubmit(input: HandleHookRuntimeInput): Promise<HookRuntimeResult> {
-  const classification = classifyUserPrompt(input.rawPayload.prompt ?? input.rawPayload.userPrompt);
   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
+    teamRuntimeContext !== null
       ? (input.receivedAt ?? new Date().toISOString())
       : (previousBinding?.teamRuntimeContextDeliveredAt ?? null);
   const binding: HookRuntimeSessionBinding = {
     version: 1,
     target: input.target,
     sessionKey,
-    taskId: contract.taskId,
-    contractPath: paths.contractPath,
     cwd: optionalPayloadString(input.rawPayload.cwd),
-    route: contract.route,
     teamRuntimeContextDeliveredAt,
+    knowledgeContextDeliveredAt: previousBinding?.knowledgeContextDeliveredAt ?? null,
     updatedAt: input.receivedAt ?? new Date().toISOString(),
   };
 
-  await writeTaskContract(paths.contractPath, contract, { overwrite: true });
   await writeJsonFile(paths.bindingPath, binding);
 
-  const visibleContext = createUserPromptVisibleContext({
-    classification,
-    contract,
-    contractPath: paths.contractPath,
-  });
-  let output =
-    visibleContext === null || !shouldShowDiagnostics
-      ? null
-      : hookOutput(input.event.type, {
-          additionalContext: visibleContext,
-        });
-  if (teamRuntimeContext !== null && shouldShowDiagnostics) {
+  let output: Record<string, unknown> | null = null;
+  if (teamRuntimeContext !== null) {
     output = appendAdditionalContext(output, input.event.type, teamRuntimeContext);
   }
 
   return createRuntimeResult(input, output, {
-    summary: "User prompt observed; Task Contract prepared.",
-    stateWrites: [paths.contractPath, paths.bindingPath],
+    summary: "User prompt observed; session binding updated.",
+    stateWrites: [paths.bindingPath],
   });
 }
 
@@ -862,46 +1039,14 @@ async function handlePreToolUse(input: HandleHookRuntimeInput): Promise<HookRunt
 }
 
 async function handlePostToolUse(input: HandleHookRuntimeInput): Promise<HookRuntimeResult> {
-  const contract = await readActiveContract(input.homeDir, input.rawPayload);
-  const binding = await readSessionBinding(input.homeDir, input.rawPayload);
-  if (contract === null || binding?.contractPath === null || binding?.contractPath === undefined) {
-    return handleAdditionalContext(input, input.event.type);
-  }
-
-  const status = optionalPayloadNumber(input.rawPayload.exit_code ?? input.rawPayload.exitCode);
-  const nextContract: TaskContract = {
-    ...contract,
-    evidence: {
-      metadataOnly: true,
-      items: [
-        ...contract.evidence.items,
-        {
-          type: "command-result",
-          id: input.event.eventId,
-          status: status === 0 ? "pass" : status === null ? "unknown" : "fail",
-          summary: input.event.payload.summary,
-          rawOutputStored: false,
-          sourceContentStored: false,
-        },
-      ],
-    },
-  };
-  await writeTaskContract(binding.contractPath, nextContract, { overwrite: true });
-
-  return createRuntimeResult(input, null, {
-    summary: "Post-tool metadata evidence recorded.",
-    stateWrites: [binding.contractPath],
-  });
+  return handleAdditionalContext(input, input.event.type);
 }
 
 async function handleCompletionObservation(
   input: HandleHookRuntimeInput,
 ): Promise<HookRuntimeResult> {
-  const contract = await readActiveContract(input.homeDir, input.rawPayload);
-  const suffix =
-    contract === null ? "without an active Task Contract" : `for Task Contract ${contract.taskId}`;
   return createRuntimeResult(input, null, {
-    summary: `${input.event.type} observed ${suffix}; no completion control enforced.`,
+    summary: `${input.event.type} observed as metadata-only hook context.`,
   });
 }
 
@@ -991,6 +1136,56 @@ function appendAdditionalContext(
   };
 }
 
+function appendDevelopmentHookDiagnostics(
+  input: HandleHookRuntimeInput,
+  result: HookRuntimeResult,
+): HookRuntimeResult {
+  if (
+    input.teamRuntimeDisplayMode !== "development" ||
+    COMPLETION_EVENTS_WITHOUT_DEVELOPMENT_DIAGNOSTICS.has(input.event.type) ||
+    !canDeliverTeamMessagesFromHook(input.target, input.event.type)
+  ) {
+    return result;
+  }
+  return {
+    ...result,
+    output: appendAdditionalContext(
+      result.output,
+      input.event.type,
+      formatDevelopmentHookDiagnostics(input),
+    ),
+  };
+}
+
+function isActiveClaudeStopHook(input: HandleHookRuntimeInput): boolean {
+  return (
+    input.target === "claude" &&
+    (input.event.type === "Stop" || input.event.type === "SubagentStop") &&
+    input.rawPayload.stop_hook_active === true
+  );
+}
+
+function formatDevelopmentHookDiagnostics(input: HandleHookRuntimeInput): string {
+  const metadata = Object.entries(input.event.payload.metadata);
+  const inputFields = Object.keys(input.rawPayload)
+    .map((field) => field.replace(/[^A-Za-z0-9._-]/g, "-").slice(0, 80))
+    .filter((field) => field.length > 0)
+    .slice(0, 30);
+  return [
+    "EvoDev hook development diagnostics",
+    `Target: ${input.target}`,
+    `Event: ${input.event.type}`,
+    `Summary: ${input.event.payload.summary}`,
+    `Input fields: ${inputFields.join(", ") || "none"}`,
+    "Normalized metadata:",
+    ...(metadata.length === 0
+      ? ["- none"]
+      : metadata.map(([key, value]) => `- ${key}: ${formatMetadataValue(value)}`)),
+    `Redactions: ${input.event.payload.redactions.join(", ") || "none"}`,
+    "Raw payload included: false",
+  ].join("\n");
+}
+
 function formatTeamInboxContext(messages: TeamMessageRecord[]): string {
   const blocks = messages.map((message) =>
     [
@@ -1014,113 +1209,6 @@ function truncateTeamMessageBody(value: string): string {
   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>,
-): TaskContract {
-  const sessionKey = resolveHookSessionKey(input.rawPayload);
-  const targetName = formatHookTargetName(input.target);
-  const contract = createTaskContract({
-    title: `${targetName} hook task ${sessionKey}`,
-    summary: `${targetName} prompt classified as ${classification.kind}; raw prompt is not stored by EvoDev.`,
-    projectId: null,
-  });
-
-  return {
-    ...contract,
-    currentState: {
-      summary: `UserPromptSubmit received through ${targetName} hooks; raw prompt omitted from Task Contract.`,
-      evidenceRefs: [],
-    },
-    targetState: {
-      summary: `Complete the ${classification.kind} task through EvoDev-controlled workflow.`,
-      nonGoals: ["Do not store raw prompts, transcripts, source content, secrets, or raw output."],
-      constraints: [
-        `prompt-kind:${classification.kind}`,
-        ...classification.riskTerms.map((term) => `risk:${term}`),
-      ],
-    },
-    scope: {
-      ...contract.scope,
-      requiresUserConfirmation: classification.riskTerms,
-    },
-    context: {
-      ...contract.context,
-      assumptions: [
-        `hook-session:${sessionKey}`,
-        `cwd:${optionalPayloadString(input.rawPayload.cwd) ?? "unknown"}`,
-      ],
-      openQuestions: classification.needsClarification
-        ? ["User request may need clarification before broad changes."]
-        : [],
-    },
-  };
-}
-
-function formatHookTargetName(target: CodeAgentHookTarget): string {
-  return target === "codex" ? "Codex" : "Claude";
-}
-
-function classifyUserPrompt(value: unknown): {
-  kind: string;
-  riskTerms: string[];
-  needsClarification: boolean;
-} {
-  const text = typeof value === "string" ? value.toLowerCase() : "";
-  const riskTerms = [
-    "security",
-    "release",
-    "publish",
-    "hook",
-    "memory",
-    "learning",
-    "secret",
-    "privacy",
-  ].filter((term) => text.includes(term));
-  let kind = "feature";
-  if (/\bbug|fix|error|failed|failure\b/.test(text)) kind = "bugfix";
-  if (/\brefactor|migration|migrate\b/.test(text)) kind = "refactor";
-  if (/\breview|audit\b/.test(text)) kind = "review";
-  if (/\btest|coverage\b/.test(text)) kind = "test";
-  if (/\bdoc|readme|guide\b/.test(text)) kind = "docs";
-  if (riskTerms.includes("security") || riskTerms.includes("privacy")) kind = "security";
-  if (riskTerms.includes("release") || riskTerms.includes("publish")) kind = "release";
-  return {
-    kind,
-    riskTerms,
-    needsClarification: text.trim().length < 12 || /\bmaybe|unclear|not sure\b/.test(text),
-  };
-}
-
-async function readActiveContract(
-  homeDir: string,
-  payload: Record<string, unknown>,
-): Promise<TaskContract | null> {
-  const binding = await readSessionBinding(homeDir, payload);
-  if (binding?.contractPath === null || binding?.contractPath === undefined) return null;
-  try {
-    return JSON.parse(await readFile(binding.contractPath, "utf8")) as TaskContract;
-  } catch (error) {
-    if (isNotFoundError(error)) return null;
-    throw error;
-  }
-}
-
 async function readSessionBinding(
   homeDir: string,
   payload: Record<string, unknown>,
@@ -1139,7 +1227,7 @@ function resolveHookSessionKey(payload: Record<string, unknown>): string {
   const sessionId = optionalPayloadString(payload.session_id ?? payload.sessionId);
   const cwd = optionalPayloadString(payload.cwd);
   const source = sessionId ?? cwd ?? "local";
-  return `session-${createHash("sha256").update(source).digest("hex").slice(0, 16)}`;
+  return `session-${sha256Short(source)}`;
 }
 
 async function writeJsonFile(path: string, value: unknown): Promise<void> {
@@ -1155,10 +1243,6 @@ function safeDiagnosticId(value: string): string {
   return value.replace(/[^A-Za-z0-9._-]/g, "-").slice(0, 120) || "unknown";
 }
 
-function optionalPayloadNumber(value: unknown): number | null {
-  return typeof value === "number" && Number.isFinite(value) ? value : null;
-}
-
 function isNotFoundError(error: unknown): boolean {
   return (
     error instanceof Error && "code" in error && (error as NodeJS.ErrnoException).code === "ENOENT"
@@ -1297,7 +1381,7 @@ function stableEventId(
 
 function hashOptionalIdentifier(value: unknown): string | null {
   if (typeof value !== "string" || value.length === 0) return null;
-  return `sha256-${createHash("sha256").update(value).digest("hex").slice(0, 16)}`;
+  return `sha256-${sha256Short(value)}`;
 }
 
 function optionalBoolean(value: unknown, fallback: boolean, path: string): boolean {

package/src/index.ts

@@ -4,17 +4,28 @@ export * from "./code-agent-traces/index.ts";
 export * from "./config/index.ts";
 export * from "./daemon/index.ts";
 export * from "./evolution/index.ts";
+export * as evolutionCandidates from "./evolution/candidates/index.ts";
+export * as evolutionControl from "./evolution/control/index.ts";
+export * as evolutionEvidence from "./evolution/evidence/index.ts";
+export * from "./evolution/evidence/session-memory/index.ts";
+export * from "./evolution/knowledge/index.ts";
+export * as evolutionKnowledge from "./evolution/knowledge/index.ts";
+export * from "./evolution/knowledge/changes.ts";
+export * from "./evolution/knowledge/change-store.ts";
+export * from "./evolution/knowledge/freshness.ts";
+export * from "./evolution/knowledge/review.ts";
+export * as evolutionProcessor from "./evolution/processor/index.ts";
+export * from "./evolution/review/index.ts";
+export * as evolutionReview from "./evolution/review/index.ts";
+export * as evolutionTriggers from "./evolution/triggers/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";
 export * from "./plugins/index.ts";
-export * from "./project/index.ts";
 export * from "./protected-zones/index.ts";
+export * from "./projects/index.ts";
 export * from "./runtime-logs/index.ts";
 export * from "./sync/index.ts";
-export * from "./task/index.ts";
 export * from "./team/index.ts";
 export * from "./team/mcp.ts";
 export * from "./workflow/index.ts";