@evo-dev/core 0.0.1-alpha.5 → 0.0.1-alpha.7

package/src/hooks/index.ts

@@ -14,13 +14,8 @@ import {
   enqueueEvolutionTrigger,
   resolveEvolutionTriggerDecision,
 } from "../evolution/triggers/index.ts";
-import { resolveTraceTeamContext } from "../runtime-logs/index.ts";
-import {
-  type TaskContract,
-  createTaskContract,
-  routeTaskContract,
-  writeTaskContract,
-} from "../task/index.ts";
+import { recordDiscoveredProject } from "../projects/index.ts";
+import { resolveTraceSessionKey, resolveTraceTeamContext } from "../runtime-logs/index.ts";
 import {
   type TeamMessageRecord,
   createTeamRoleRuntimeContext,
@@ -159,10 +154,7 @@ 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;
 }
@@ -234,6 +226,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 {
@@ -424,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"),
   };
 }
 
@@ -447,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);
@@ -485,12 +489,15 @@ export async function handleHookRuntime(input: HandleHookRuntimeInput): Promise<
   const messageDiagnostics = await deliverPendingTeamMessagesFromHook(input, result);
   const scopedContextDiagnostics = await injectScopedKnowledgeContextFromHook(input, result);
   const teamStateDiagnostics = await recordTeamAgentHookStateFromHook(input);
-  return appendRuntimeDiagnostics(
+  const completed = appendRuntimeDiagnostics(
     appendRuntimeDiagnostics(
       appendRuntimeDiagnostics(
         appendRuntimeDiagnostics(
           appendRuntimeDiagnostics(
-            appendRuntimeDiagnostics(result, diagnostics),
+            appendRuntimeDiagnostics(
+              appendRuntimeDiagnostics(result, diagnostics),
+              projectDiagnostics,
+            ),
             sessionMemoryDiagnostics,
           ),
           evolutionDiagnostics,
@@ -501,6 +508,7 @@ export async function handleHookRuntime(input: HandleHookRuntimeInput): Promise<
     ),
     teamStateDiagnostics,
   );
+  return appendDevelopmentHookDiagnostics(input, completed);
 }
 
 export function formatHookRuntimeOutput(result: HookRuntimeResult): string {
@@ -524,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> {
@@ -825,17 +868,14 @@ 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
       ? (input.receivedAt ?? new Date().toISOString())
@@ -844,35 +884,21 @@ async function handleUserPromptSubmit(input: HandleHookRuntimeInput): Promise<Ho
     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 visibleContext = createUserPromptVisibleContext({
-    classification,
-    contract,
-    contractPath: paths.contractPath,
-  });
-  let output =
-    visibleContext === null || !shouldShowDiagnostics
-      ? null
-      : hookOutput(input.event.type, {
-          additionalContext: visibleContext,
-        });
+  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],
   });
 }
 
@@ -909,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.`,
   });
 }
 
@@ -1038,6 +1032,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) =>
     [
@@ -1061,113 +1105,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>,
@@ -1202,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"

package/src/index.ts

@@ -18,11 +18,10 @@ export * from "./hooks/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";