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

package/src/hooks/index.ts

@@ -1,15 +1,31 @@
-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 { resolveTraceTeamContext } from "../runtime-logs/index.ts";
 import {
-  type TaskContract,
-  createTaskContract,
-  routeTaskContract,
-  writeTaskContract,
-} from "../task/index.ts";
-import { recordTeamAgentNativeSession, resolveTeamRunPaths } from "../team/index.ts";
+  type SessionMemoryPolicySnapshot,
+  updateSessionMemoryFromHook,
+} from "../evolution/evidence/session-memory/index.ts";
+import {
+  createScopedKnowledgeContextPack,
+  formatScopedKnowledgePromptBlock,
+  hasContextInjectionReceipt,
+  writeContextInjectionReceipt,
+} from "../evolution/knowledge/index.ts";
+import {
+  enqueueEvolutionTrigger,
+  resolveEvolutionTriggerDecision,
+} from "../evolution/triggers/index.ts";
+import { recordDiscoveredProject } from "../projects/index.ts";
+import { resolveTraceSessionKey, resolveTraceTeamContext } from "../runtime-logs/index.ts";
+import {
+  type TeamMessageRecord,
+  createTeamRoleRuntimeContext,
+  markTeamMessagesDelivered,
+  readPendingTeamMessagesForRole,
+  recordTeamAgentNativeSession,
+  resolveTeamRunPaths,
+  updateTeamAgentHookState,
+} from "../team/index.ts";
+import { sha256Short } from "../utils/index.ts";
 
 export const CANONICAL_HOOK_EVENT_TYPES = [
   "SessionStart",
@@ -138,10 +154,8 @@ 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;
   updatedAt: string;
 }
 
@@ -159,10 +173,13 @@ 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;
+  sessionMemoryPolicy?: Partial<SessionMemoryPolicySnapshot>;
 }
 
 const DEFAULT_EVENT_SETTINGS: Record<CanonicalHookEventType, boolean> = {
@@ -195,6 +212,26 @@ 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",
+]);
+const COMPLETION_EVENTS_WITHOUT_DEVELOPMENT_DIAGNOSTICS = new Set<CanonicalHookEventType>([
+  "Stop",
+  "SubagentStop",
+  "TaskCompleted",
+  "TeammateIdle",
+]);
 
 export function createDefaultHookSettings(): HookSettings {
   return {
@@ -210,8 +247,8 @@ export function createDefaultHookSettings(): HookSettings {
       },
     },
     observability: {
-      metadataOnly: false,
-      rawPayloadStorage: true,
+      metadataOnly: true,
+      rawPayloadStorage: false,
       appendEvents: false,
     },
     learning: {
@@ -244,8 +281,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 +314,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 +326,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 +334,7 @@ export function normalizeHookEvent(input: NormalizeHookEventInput): HookEventV1
       metadata,
       redactions,
       redactionCount: redactions.length,
-      rawContentIncluded: true,
+      rawContentIncluded: false,
     },
     policy: {
       classification: "local-private",
@@ -338,8 +375,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",
@@ -385,12 +422,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"),
   };
 }
 
@@ -408,7 +444,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);
@@ -437,11 +480,35 @@ export async function handleHookRuntime(input: HandleHookRuntimeInput): Promise<
   } else if (result === undefined) {
     result = await handleAdditionalContext(input, input.event.type);
   }
-  const evolutionDiagnostics = await recordEvolutionTriggerFromHook(input);
-  return appendRuntimeDiagnostics(
-    appendRuntimeDiagnostics(result, diagnostics),
-    evolutionDiagnostics,
+  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 teamStateDiagnostics = await recordTeamAgentHookStateFromHook(input);
+  const completed = appendRuntimeDiagnostics(
+    appendRuntimeDiagnostics(
+      appendRuntimeDiagnostics(
+        appendRuntimeDiagnostics(
+          appendRuntimeDiagnostics(
+            appendRuntimeDiagnostics(
+              appendRuntimeDiagnostics(result, diagnostics),
+              projectDiagnostics,
+            ),
+            sessionMemoryDiagnostics,
+          ),
+          evolutionDiagnostics,
+        ),
+        messageDiagnostics,
+      ),
+      scopedContextDiagnostics,
+    ),
+    teamStateDiagnostics,
   );
+  return appendDevelopmentHookDiagnostics(input, completed);
 }
 
 export function formatHookRuntimeOutput(result: HookRuntimeResult): string {
@@ -465,6 +532,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> {
@@ -568,6 +670,183 @@ 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,
+): 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,54 +862,67 @@ 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.",
   });
 }
 
 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 teamRuntimeContextDeliveredAt =
+    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,
     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(" ");
-
-  return createRuntimeResult(input, hookOutput(input.event.type, { additionalContext: context }), {
-    summary: "User prompt observed and advisory context prepared.",
-    stateWrites: [paths.contractPath, paths.bindingPath],
+  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; session binding updated.",
+    stateWrites: [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"
@@ -643,46 +935,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.`,
   });
 }
 
@@ -748,96 +1008,101 @@ function hookOutput(
   };
 }
 
-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 local trace only.`,
-    projectId: null,
-  });
-
+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 {
-    ...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."]
-        : [],
+    ...output,
+    hookSpecificOutput: {
+      ...hookSpecificOutput,
+      hookEventName:
+        typeof hookSpecificOutput.hookEventName === "string"
+          ? hookSpecificOutput.hookEventName
+          : eventName,
+      additionalContext: previous === "" ? context : `${previous}\n\n${context}`,
     },
   };
 }
 
-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";
+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 {
-    kind,
-    riskTerms,
-    needsClarification: text.trim().length < 12 || /\bmaybe|unclear|not sure\b/.test(text),
+    ...result,
+    output: appendAdditionalContext(
+      result.output,
+      input.event.type,
+      formatDevelopmentHookDiagnostics(input),
+    ),
   };
 }
 
-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;
-  }
+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) =>
+    [
+      "[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}]`;
 }
 
 async function readSessionBinding(
@@ -858,7 +1123,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> {
@@ -874,10 +1139,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"
@@ -927,9 +1188,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)
@@ -1018,7 +1277,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 {