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

package/dist/index.js

@@ -120,6 +120,7 @@ __export(exports_candidates, {
   readEvolutionReviewSnapshot: () => readEvolutionReviewSnapshot,
   readEvolutionRepoProposalById: () => readEvolutionRepoProposalById,
   readEvolutionKnowledgeRecordById: () => readEvolutionKnowledgeRecordById,
+  markEvolutionRepoProposalApplied: () => markEvolutionRepoProposalApplied,
   listEvolutionKnowledgeReviewHistory: () => listEvolutionKnowledgeReviewHistory,
   listEvolutionKnowledgeRecords: () => listEvolutionKnowledgeRecords,
   listEvolutionEvosCases: () => listEvolutionEvosCases
@@ -1167,23 +1168,64 @@ async function updateEvolutionRepoProposalReviewState(input) {
       }
     };
     validateEvolutionRepoProposal(next);
-    await writeJsonFile(path, next, { overwrite: true });
-    const allRunProposals = await readJsonFiles(paths.repoProposalsDir, parseRepoProposal);
-    await writeJsonFile(paths.repoProposalsIndexPath, {
-      schemaVersion: 1,
-      projectKey: next.projectKey,
-      runId: next.provenance.runId,
-      updatedAt: changedAt,
-      proposals: allRunProposals.map((proposal) => ({
-        id: proposal.id,
-        kind: proposal.kind,
-        title: proposal.title,
-        reviewState: proposal.reviewState
-      }))
-    }, { overwrite: true });
+    await writeRepoProposalAndIndex({ homeDir: input.homeDir, proposal: next, changedAt });
+    return { path, record: next, changed: true };
+  });
+}
+async function markEvolutionRepoProposalApplied(input) {
+  return await withEvolutionReviewDecisionLock({ homeDir: input.homeDir, kind: "repo-proposal", itemId: input.proposalId }, async () => {
+    const record = await readEvolutionRepoProposalById(input);
+    if (!hasConcreteRepoProposalChanges(record)) {
+      throw new Error("Repo proposal has no concrete repository changes to apply.");
+    }
+    if (input.expectedReviewState !== undefined && record.reviewState !== input.expectedReviewState) {
+      throw new Error("Repo proposal review state changed before it was marked applied.");
+    }
+    const paths = resolveEvolutionPaths({
+      homeDir: input.homeDir,
+      projectKey: record.projectKey,
+      runId: record.provenance.runId
+    });
+    const path = join3(paths.repoProposalsDir, `${record.id}.json`);
+    if (record.reviewState === "applied")
+      return { path, record, changed: false };
+    if (record.reviewState !== "accepted") {
+      throw new Error("Only accepted repo proposals can be marked applied.");
+    }
+    const changedAt = normalizeTimestamp2(input.now);
+    const next = {
+      ...record,
+      reviewState: "applied",
+      reviewStateChangedAt: changedAt
+    };
+    validateEvolutionRepoProposal(next);
+    await writeRepoProposalAndIndex({ homeDir: input.homeDir, proposal: next, changedAt });
     return { path, record: next, changed: true };
   });
 }
+async function writeRepoProposalAndIndex(input) {
+  const paths = resolveEvolutionPaths({
+    homeDir: input.homeDir,
+    projectKey: input.proposal.projectKey,
+    runId: input.proposal.provenance.runId
+  });
+  await writeJsonFile(join3(paths.repoProposalsDir, `${input.proposal.id}.json`), input.proposal, {
+    overwrite: true
+  });
+  const allRunProposals = await readJsonFiles(paths.repoProposalsDir, parseRepoProposal);
+  await writeJsonFile(paths.repoProposalsIndexPath, {
+    schemaVersion: 1,
+    projectKey: input.proposal.projectKey,
+    runId: input.proposal.provenance.runId,
+    updatedAt: input.changedAt,
+    proposals: allRunProposals.map((proposal) => ({
+      id: proposal.id,
+      kind: proposal.kind,
+      title: proposal.title,
+      reviewState: proposal.reviewState
+    }))
+  }, { overwrite: true });
+}
 function parseKnowledgeReviewHistoryRecord(value) {
   if (!isRecord2(value))
     throw new Error("Knowledge review history record must be an object.");
@@ -4567,16 +4609,6 @@ var DEFAULT_AGENT_PERMISSIONS = {
 };
 var FORBIDDEN_INPUTS = ["rawPrompts", "secrets", "rawCommandLogs", "sourceCorpus"];
 var SAFE_AGENT_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,99}$/;
-var PRIVACY_ADVISORY_PATTERN = /raw prompt|rawprompt|source corpus|sourcecorpus|secret|\.env|raw command|raw log|internal url|private url|network|write files|run commands|spawn agents|write memory/i;
-var LENS_TO_EXPERTISE = {
-  review: ["code-review"],
-  qa: ["qa", "verification"],
-  security: ["security", "privacy"],
-  release: ["release", "packaging"],
-  architecture: ["architecture"],
-  migration: ["migration", "impact-analysis"],
-  test: ["testing"]
-};
 function createDefaultAgentPermissions() {
   return { ...DEFAULT_AGENT_PERMISSIONS };
 }
@@ -4623,50 +4655,6 @@ function parseAgentProfile(value) {
 async function readAgentProfile(path) {
   return parseAgentProfile(JSON.parse(await readFile4(path, "utf8")));
 }
-function composeAgentDryRun(input) {
-  const mode = input.contract.route.mode;
-  const workflowId = input.workflowId ?? input.contract.route.workflowId;
-  const warnings = [];
-  const permissions = createDefaultAgentPermissions();
-  const requestedLenses = dedupeLenses(input.lenses ?? []);
-  const advisories = collectPrivacyBoundaryAdvisories(input.contract, requestedLenses, workflowId);
-  if (mode === "minimal") {
-    return {
-      ok: advisories.length === 0,
-      taskId: input.contract.taskId,
-      mode,
-      workflowId,
-      agents: [],
-      permissions,
-      mergePlan: createMergePlan([]),
-      warnings,
-      advisories,
-      rationale: "Minimal mode does not force dynamic agents by default."
-    };
-  }
-  const selectedLenses = selectLenses(mode, requestedLenses, workflowId, input.contract.route.requiredReview);
-  const agents = selectedLenses.map((lens) => ({
-    profile: createDynamicProfile(lens, input.contract, permissions),
-    lens,
-    reason: createLensReason(lens, mode, workflowId),
-    plannedOnly: true
-  }));
-  if (mode === "standard" && agents.length > 1) {
-    warnings.push("Standard mode advisory selected more than one reviewer/triager.");
-  }
-  return {
-    ok: advisories.length === 0,
-    taskId: input.contract.taskId,
-    mode,
-    workflowId,
-    agents,
-    permissions,
-    mergePlan: createMergePlan(agents),
-    warnings,
-    advisories,
-    rationale: agents.length === 0 ? "No dynamic agents selected; deterministic verification may be sufficient." : `Selected ${agents.length} planned-only agent(s) based on mode/workflow/lenses.`
-  };
-}
 function loadAgentContextDryRun(profile) {
   const parsed = parseAgentProfile(profile);
   return {
@@ -4760,36 +4748,6 @@ function mergeReviewFindings(outputs) {
   }
   return { acceptedFindings: [...byKey.values()], unresolvedConflicts: conflicts };
 }
-function formatAgentComposeDryRun(plan) {
-  return [
-    "EvoDev agent compose dry-run",
-    "",
-    `Task: ${plan.taskId}`,
-    `Mode: ${plan.mode ?? "not routed"}`,
-    `Workflow: ${plan.workflowId ?? "none"}`,
-    `Rationale: ${plan.rationale}`,
-    "No-write/no-spawn: true",
-    "Privacy: local-private, metadata-only, raw prompts/source/secrets/logs forbidden",
-    "Agents:",
-    ...plan.agents.length === 0 ? ["  - none"] : plan.agents.map((agent) => `  - ${agent.profile.id} [${agent.lens}] traits=${agent.profile.traits.expertise.join(",")} schema=${agent.profile.output.schema} plannedOnly=${agent.plannedOnly}`),
-    "Inputs:",
-    ...plan.agents.length === 0 ? ["  - none"] : [
-      `  - required: ${plan.agents[0].profile.inputs.required.join(",")}`,
-      `  - optional: ${plan.agents[0].profile.inputs.optional.join(",")}`,
-      `  - forbidden: ${plan.agents[0].profile.inputs.forbidden.join(",")}`
-    ],
-    "Permissions:",
-    ...Object.entries(plan.permissions).map(([key, value]) => `  - ${key}: ${value}`),
-    "Merge plan:",
-    `  - strategy: ${plan.mergePlan.strategy}`,
-    `  - outputSchema: ${plan.mergePlan.outputSchema ?? "none"}`,
-    "Warnings:",
-    ...plan.warnings.length === 0 ? ["  - none"] : plan.warnings.map((warning) => `  - ${warning}`),
-    "Advisories:",
-    ...plan.advisories.length === 0 ? ["  - none"] : plan.advisories.map((advisory) => `  - ${advisory}`)
-  ].join(`
-`);
-}
 function formatAgentContextDryRun(bundle) {
   return [
     "EvoDev agent load-context dry-run",
@@ -4807,98 +4765,6 @@ function formatAgentContextDryRun(bundle) {
   ].join(`
 `);
 }
-function createDynamicProfile(lens, contract, permissions) {
-  return {
-    version: 1,
-    id: `dynamic-${lens}-${contract.taskId}`.slice(0, 100),
-    name: `Dynamic ${lens} reviewer`,
-    persistence: "dynamic",
-    description: `Task-scoped ${lens} profile for metadata-only dry-run planning.`,
-    traits: {
-      expertise: LENS_TO_EXPERTISE[lens],
-      stance: ["skeptical-reviewer"],
-      approach: ["evidence-first", "advisory"],
-      domain: ["software-rd"]
-    },
-    inputs: {
-      required: ["taskContract", "scope", "evidenceSummary"],
-      optional: ["workflowPlan"],
-      forbidden: FORBIDDEN_INPUTS
-    },
-    permissions,
-    output: {
-      schema: "review-findings-v1",
-      requiredFields: ["summary", "findings", "confidence", "evidenceRefs"]
-    },
-    privacy: {
-      classification: "local-private",
-      metadataOnly: true,
-      rawPromptStored: false,
-      sourceContentStored: false
-    }
-  };
-}
-function selectLenses(mode, requested, workflowId, requiredReview) {
-  if (requested.length > 0)
-    return mode === "standard" ? requested.slice(0, 1) : requested;
-  if (mode === "standard")
-    return requiredReview.length > 0 ? ["review"] : [];
-  if (mode === "rigorous") {
-    if (workflowId?.includes("security"))
-      return ["security", "review"];
-    if (workflowId?.includes("release"))
-      return ["release", "security"];
-    if (workflowId?.includes("migration"))
-      return ["migration", "architecture"];
-    if (workflowId?.includes("architecture"))
-      return ["architecture", "review"];
-    return requiredReview.length > 0 ? ["review", "qa"] : [];
-  }
-  return [];
-}
-function createMergePlan(agents) {
-  if (agents.length === 0)
-    return {
-      strategy: "none",
-      outputSchema: null,
-      dedupeBy: [],
-      conflictPolicy: [],
-      advisoryCategories: []
-    };
-  if (agents.length === 1)
-    return {
-      strategy: "single-output",
-      outputSchema: agents[0].profile.output.schema,
-      dedupeBy: [],
-      conflictPolicy: [],
-      advisoryCategories: []
-    };
-  return {
-    strategy: "dedupe-preserve-conflicts",
-    outputSchema: "review-findings-v1",
-    dedupeBy: ["category", "path", "line", "title"],
-    conflictPolicy: ["preserve dissent", "keep higher severity unless evidence refutes"],
-    advisoryCategories: ["security", "privacy", "release"]
-  };
-}
-function createLensReason(lens, mode, workflowId) {
-  return `${lens} lens selected for ${mode ?? "unrouted"} mode${workflowId ? ` and workflow ${workflowId}` : ""}.`;
-}
-function collectPrivacyBoundaryAdvisories(contract, lenses, workflowId) {
-  const text2 = [
-    contract.source.summary,
-    contract.currentState.summary,
-    contract.targetState.summary,
-    contract.route.rationale,
-    workflowId ?? "",
-    ...contract.scope.allowedOperations,
-    ...contract.scope.requiresUserConfirmation,
-    ...lenses
-  ].join(" ");
-  return PRIVACY_ADVISORY_PATTERN.test(text2) ? [
-    "Agent planning detected privacy/risky context requiring raw data, writes, commands, network, spawning, or memory."
-  ] : [];
-}
 function validateRequiredObject(output, fields) {
   if (!isRecord4(output))
     return { ok: false, errors: ["Output must be an object."] };
@@ -4911,9 +4777,6 @@ function normalizeAgentPermissions(value) {
 function isKnownOutputSchema(value) {
   return value === "review-findings-v1" || value === "verification-summary-v1" || value === "design-options-v1";
 }
-function dedupeLenses(lenses) {
-  return [...new Set(lenses)];
-}
 function severityRank(severity) {
   return { info: 0, low: 1, medium: 2, high: 3, critical: 4 }[severity];
 }
@@ -5141,8 +5004,12 @@ __export(exports_code_agent_traces, {
   listCodeAgentTraceRefs: () => listCodeAgentTraceRefs,
   createCodeAgentTraceRef: () => createCodeAgentTraceRef
 });
-import { mkdir as mkdir5, readFile as readFile6, readdir as readdir6, stat as stat4, writeFile as writeFile4 } from "node:fs/promises";
-import { dirname as dirname5, isAbsolute as isAbsolute4, join as join7, normalize, relative as relative5 } from "node:path";
+import { mkdir as mkdir5, readFile as readFile7, readdir as readdir7, stat as stat5, writeFile as writeFile4 } from "node:fs/promises";
+import { dirname as dirname6, isAbsolute as isAbsolute5, join as join8, normalize, relative as relative5 } from "node:path";
+
+// packages/core/src/projects/index.ts
+import { lstat, readFile as readFile6, readdir as readdir6, realpath, stat as stat4 } from "node:fs/promises";
+import { basename, dirname as dirname5, isAbsolute as isAbsolute4, join as join7, parse } from "node:path";
 
 // packages/core/src/runtime-logs/index.ts
 var exports_runtime_logs = {};
@@ -5613,6 +5480,299 @@ function isRecord5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
+// packages/core/src/projects/index.ts
+class ProjectRegistrationError extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "ProjectRegistrationError";
+    this.code = code;
+  }
+}
+function resolveProjectRegistryPaths(homeDir) {
+  const paths = resolveEvoDevPaths(homeDir);
+  const discoveredDir = join7(paths.stateDir, "projects", "discovered");
+  const registeredDir = join7(paths.rootDir, "projects");
+  return {
+    discoveredDir,
+    registeredDir,
+    discoveredPath: (projectKey) => join7(discoveredDir, `${projectKey}.json`),
+    registeredPath: (projectKey) => join7(registeredDir, projectKey, "workspace.json")
+  };
+}
+async function resolveProjectWorkspaceFromCwd(input) {
+  if (!isAbsolute4(input.cwd))
+    return null;
+  let cwd;
+  try {
+    const info = await stat4(input.cwd);
+    if (!info.isDirectory())
+      return null;
+    cwd = await realpath(input.cwd);
+  } catch (error) {
+    if (isNotFoundError(error))
+      return null;
+    throw error;
+  }
+  const gitRoot = await findNearestGitRoot(cwd);
+  const workspaceRoot = gitRoot ?? cwd;
+  return {
+    projectKey: sanitizeStorageId(resolveProjectLogKey(input.homeDir, workspaceRoot), "project"),
+    displayName: basename(workspaceRoot) || parse(workspaceRoot).root,
+    workspaceRoot,
+    workspaceKind: gitRoot === null ? "directory" : "git",
+    cwd
+  };
+}
+async function recordDiscoveredProject(input) {
+  const workspace = await resolveProjectWorkspaceFromCwd(input);
+  if (workspace === null)
+    return null;
+  const now = normalizeTimestamp(input.now);
+  const paths = resolveProjectRegistryPaths(input.homeDir);
+  const path = paths.discoveredPath(workspace.projectKey);
+  const existing = await readDiscoveredProject(path);
+  const record = {
+    schemaVersion: 1,
+    kind: "discovered-project",
+    projectKey: workspace.projectKey,
+    displayName: workspace.displayName,
+    workspaceRoot: workspace.workspaceRoot,
+    lastCwd: workspace.cwd,
+    workspaceKind: workspace.workspaceKind,
+    sourceTargets: mergeTargets(existing?.sourceTargets ?? [], [input.target]),
+    lastSessionKey: normalizeSessionKey(input.sessionKey ?? existing?.lastSessionKey ?? null),
+    firstSeenAt: existing?.firstSeenAt ?? now,
+    lastSeenAt: now,
+    localOnly: true,
+    sourceContentStored: false
+  };
+  await writeJsonFile(path, record);
+  return { record, path };
+}
+async function listDiscoveredProjects(input) {
+  const paths = resolveProjectRegistryPaths(input.homeDir);
+  const records = new Map;
+  for (const path of await listJsonFilePaths(paths.discoveredDir)) {
+    const record = await readDiscoveredProject(path);
+    if (record !== null)
+      mergeDiscoveredRecord(records, record);
+  }
+  for (const binding of await listLegacyHookBindings(input.homeDir)) {
+    if (binding.cwd === null)
+      continue;
+    const workspace = await resolveProjectWorkspaceFromCwd({
+      homeDir: input.homeDir,
+      cwd: binding.cwd
+    });
+    if (workspace === null)
+      continue;
+    mergeDiscoveredRecord(records, {
+      schemaVersion: 1,
+      kind: "discovered-project",
+      projectKey: workspace.projectKey,
+      displayName: workspace.displayName,
+      workspaceRoot: workspace.workspaceRoot,
+      lastCwd: workspace.cwd,
+      workspaceKind: workspace.workspaceKind,
+      sourceTargets: [binding.target],
+      lastSessionKey: normalizeSessionKey(binding.sessionKey),
+      firstSeenAt: binding.updatedAt,
+      lastSeenAt: binding.updatedAt,
+      localOnly: true,
+      sourceContentStored: false
+    });
+  }
+  return [...records.values()].sort((left, right) => right.lastSeenAt.localeCompare(left.lastSeenAt) || left.projectKey.localeCompare(right.projectKey));
+}
+async function listRegisteredProjects(input) {
+  const { registeredDir } = resolveProjectRegistryPaths(input.homeDir);
+  const records = [];
+  for (const projectKey of await listDirectoryNames2(registeredDir)) {
+    const record = await readRegisteredProject(join7(registeredDir, projectKey, "workspace.json"));
+    if (record !== null && record.projectKey === projectKey)
+      records.push(record);
+  }
+  return records.sort((left, right) => right.lastSeenAt.localeCompare(left.lastSeenAt) || left.projectKey.localeCompare(right.projectKey));
+}
+async function registerDiscoveredProject(input) {
+  assertProjectKey(input.projectKey);
+  const paths = resolveProjectRegistryPaths(input.homeDir);
+  const path = paths.registeredPath(input.projectKey);
+  const existing = await readRegisteredProject(path);
+  if (existing !== null)
+    return { record: existing, path, changed: false };
+  const discovered = (await listDiscoveredProjects({ homeDir: input.homeDir })).find((record2) => record2.projectKey === input.projectKey);
+  if (discovered === undefined) {
+    throw new ProjectRegistrationError("not-found", "The project must be discovered by a local Code Agent session before it can be added.");
+  }
+  const record = {
+    schemaVersion: 1,
+    kind: "registered-project",
+    projectKey: discovered.projectKey,
+    displayName: discovered.displayName,
+    workspaceRoot: discovered.workspaceRoot,
+    workspaceKind: discovered.workspaceKind,
+    registeredAt: normalizeTimestamp(input.now),
+    lastSeenAt: discovered.lastSeenAt,
+    localOnly: true,
+    sourceContentStored: false
+  };
+  try {
+    await writeJsonFile(path, record, { overwrite: false });
+    return { record, path, changed: true };
+  } catch (error) {
+    if (!isFileExistsError(error))
+      throw error;
+    const concurrent = await readRegisteredProject(path);
+    if (concurrent !== null)
+      return { record: concurrent, path, changed: false };
+    throw new ProjectRegistrationError("conflict", "The project registration already exists.");
+  }
+}
+async function findNearestGitRoot(cwd) {
+  let current = cwd;
+  for (;; ) {
+    try {
+      const marker = await lstat(join7(current, ".git"));
+      if (marker.isDirectory() || marker.isFile())
+        return current;
+    } catch (error) {
+      if (!isNotFoundError(error))
+        throw error;
+    }
+    const parent = dirname5(current);
+    if (parent === current)
+      return null;
+    current = parent;
+  }
+}
+async function readDiscoveredProject(path) {
+  try {
+    return parseDiscoveredProject(JSON.parse(await readFile6(path, "utf8")));
+  } catch (error) {
+    if (isNotFoundError(error) || error instanceof ProjectRegistrationError)
+      return null;
+    throw error;
+  }
+}
+async function readRegisteredProject(path) {
+  try {
+    return parseRegisteredProject(JSON.parse(await readFile6(path, "utf8")));
+  } catch (error) {
+    if (isNotFoundError(error) || error instanceof ProjectRegistrationError)
+      return null;
+    throw error;
+  }
+}
+function parseDiscoveredProject(value) {
+  const record = requireRecord(value);
+  if (record.schemaVersion !== 1 || record.kind !== "discovered-project" || !isProjectKey(record.projectKey) || !isNonEmptyString2(record.displayName) || !isAbsoluteString(record.workspaceRoot) || !isAbsoluteString(record.lastCwd) || !isWorkspaceKind(record.workspaceKind) || !isDiscoveryTargetArray(record.sourceTargets) || !(record.lastSessionKey === null || isNonEmptyString2(record.lastSessionKey)) || !isNonEmptyString2(record.firstSeenAt) || !isNonEmptyString2(record.lastSeenAt) || record.localOnly !== true || record.sourceContentStored !== false) {
+    throw new ProjectRegistrationError("invalid", "Discovered project record is invalid.");
+  }
+  return record;
+}
+function parseRegisteredProject(value) {
+  const record = requireRecord(value);
+  if (record.schemaVersion !== 1 || record.kind !== "registered-project" || !isProjectKey(record.projectKey) || !isNonEmptyString2(record.displayName) || !isAbsoluteString(record.workspaceRoot) || !isWorkspaceKind(record.workspaceKind) || !isNonEmptyString2(record.registeredAt) || !isNonEmptyString2(record.lastSeenAt) || record.localOnly !== true || record.sourceContentStored !== false) {
+    throw new ProjectRegistrationError("invalid", "Registered project record is invalid.");
+  }
+  return record;
+}
+function mergeDiscoveredRecord(records, next) {
+  const previous = records.get(next.projectKey);
+  if (previous === undefined) {
+    records.set(next.projectKey, next);
+    return;
+  }
+  const newer = next.lastSeenAt >= previous.lastSeenAt ? next : previous;
+  records.set(next.projectKey, {
+    ...newer,
+    sourceTargets: mergeTargets(previous.sourceTargets, next.sourceTargets),
+    firstSeenAt: previous.firstSeenAt <= next.firstSeenAt ? previous.firstSeenAt : next.firstSeenAt,
+    lastSeenAt: previous.lastSeenAt >= next.lastSeenAt ? previous.lastSeenAt : next.lastSeenAt
+  });
+}
+function mergeTargets(left, right) {
+  return [...new Set([...left, ...right])].sort();
+}
+function normalizeSessionKey(value) {
+  if (value === null || value === undefined)
+    return null;
+  return /^session-[a-f0-9]{16}$/u.test(value) ? value : `session-${sha256Short(value)}`;
+}
+async function listLegacyHookBindings(homeDir) {
+  const roots = [
+    join7(homeDir, ".evodev", "state", "hooks", "sessions"),
+    join7(homeDir, ".evodev", "STATE", "hooks", "sessions")
+  ];
+  const bindings = [];
+  for (const root of roots) {
+    for (const sessionDir of await listDirectoryNames2(root)) {
+      try {
+        const value = JSON.parse(await readFile6(join7(root, sessionDir, "binding.json"), "utf8"));
+        if (value === null || value.target !== "claude" && value.target !== "codex" || !isNonEmptyString2(value.sessionKey) || !(value.cwd === null || isAbsoluteString(value.cwd)) || !isNonEmptyString2(value.updatedAt)) {
+          continue;
+        }
+        bindings.push({
+          target: value.target,
+          sessionKey: value.sessionKey,
+          cwd: value.cwd,
+          updatedAt: value.updatedAt
+        });
+      } catch (error) {
+        if (!isNotFoundError(error) && !(error instanceof SyntaxError))
+          throw error;
+      }
+    }
+  }
+  return bindings;
+}
+async function listJsonFilePaths(path) {
+  try {
+    return (await readdir6(path, { withFileTypes: true })).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => join7(path, entry.name)).sort();
+  } catch (error) {
+    if (isNotFoundError(error))
+      return [];
+    throw error;
+  }
+}
+async function listDirectoryNames2(path) {
+  try {
+    return (await readdir6(path, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
+  } catch (error) {
+    if (isNotFoundError(error))
+      return [];
+    throw error;
+  }
+}
+function assertProjectKey(value) {
+  if (!isProjectKey(value)) {
+    throw new ProjectRegistrationError("invalid", "projectKey is invalid.");
+  }
+}
+function isProjectKey(value) {
+  return typeof value === "string" && value !== "." && value !== ".." && /^[A-Za-z0-9._-]{1,120}$/.test(value);
+}
+function isNonEmptyString2(value) {
+  return typeof value === "string" && value.trim() !== "";
+}
+function isAbsoluteString(value) {
+  return isNonEmptyString2(value) && isAbsolute4(value);
+}
+function isWorkspaceKind(value) {
+  return value === "git" || value === "directory";
+}
+function isDiscoveryTargetArray(value) {
+  return Array.isArray(value) && value.length > 0 && value.every((item) => item === "claude" || item === "codex");
+}
+function requireRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new ProjectRegistrationError("invalid", "Project record must be an object.");
+  }
+  return value;
+}
+
 // packages/core/src/code-agent-traces/index.ts
 var CODE_AGENT_TRACE_TARGETS = ["claude", "codex"];
 var CODE_AGENT_TRACE_REF_SOURCES = [
@@ -5624,11 +5784,11 @@ var CODE_AGENT_TRACE_REF_SOURCES = [
 var SENSITIVE_IDENTIFIER_PATTERN = /https?:\/\/\S+|(^|[^a-z0-9])(secret|token|password|passwd|private|internal|api[_-]?key|apikey|credential|credentials|stdout|stderr|transcript|formattedresponse|additionalcontext)([^a-z0-9]|$)|raw[\s_-]?(payload|prompt|output|source)|source[\s_-]?dump/i;
 var SENSITIVE_PATH_PATTERN = /(^|[/\\._-])(secret|token|password|passwd|api[_-]?key|apikey|credential|credentials)([/\\._-]|$)/i;
 function resolveCodeAgentTraceRefPaths(homeDir) {
-  const rootDir = join7(resolveEvoDevPaths(homeDir).stateDir, "code-agent-traces");
+  const rootDir = join8(resolveEvoDevPaths(homeDir).stateDir, "code-agent-traces");
   return {
     rootDir,
-    claudeDir: join7(rootDir, "claude"),
-    codexDir: join7(rootDir, "codex")
+    claudeDir: join8(rootDir, "claude"),
+    codexDir: join8(rootDir, "codex")
   };
 }
 function createCodeAgentTraceRef(input) {
@@ -5701,7 +5861,7 @@ async function writeCodeAgentTraceRef(input) {
     target: ref.target,
     sessionKey: ref.sessionKey
   });
-  await mkdir5(dirname5(path), { recursive: true });
+  await mkdir5(dirname6(path), { recursive: true });
   await writeFile4(path, `${JSON.stringify(ref, null, 2)}
 `, "utf8");
   return { ref, path };
@@ -5713,7 +5873,7 @@ async function readCodeAgentTraceRef(input) {
     target: targetAndSession.target,
     sessionKey: targetAndSession.sessionKey
   });
-  const ref = sanitizeCodeAgentTraceRefForWrite(parseCodeAgentTraceRef(JSON.parse(await readFile6(path, "utf8"))));
+  const ref = sanitizeCodeAgentTraceRefForWrite(parseCodeAgentTraceRef(JSON.parse(await readFile7(path, "utf8"))));
   if (ref.id !== input.id)
     throw new Error(`Code Agent trace ref id mismatch: ${input.id}`);
   return { ref, path };
@@ -5727,8 +5887,8 @@ async function listCodeAgentTraceRefs(input) {
     for (const entry of entries) {
       if (!entry.isFile() || !entry.name.endsWith(".json"))
         continue;
-      const path = join7(dir, entry.name);
-      const ref = sanitizeCodeAgentTraceRefForWrite(parseCodeAgentTraceRef(JSON.parse(await readFile6(path, "utf8"))));
+      const path = join8(dir, entry.name);
+      const ref = sanitizeCodeAgentTraceRefForWrite(parseCodeAgentTraceRef(JSON.parse(await readFile7(path, "utf8"))));
       if (input.projectKey !== undefined && ref.projectKey !== input.projectKey)
         continue;
       if (input.runId !== undefined && ref.runId !== input.runId)
@@ -5763,15 +5923,17 @@ async function recordCodeAgentTraceRefFromHook(input) {
     payload: input.payload,
     environment
   });
+  const cwd = optionalString4(input.payload.cwd);
+  const workspace = team === null && cwd !== null ? await resolveProjectWorkspaceFromCwd({ homeDir: input.homeDir, cwd }) : null;
   const source = sessionIdFromPayload !== null || tracePathFromPayload !== null ? "hook-payload" : "environment";
   const ref = createCodeAgentTraceRef({
     target: input.target,
     sessionKey: resolveTraceSessionKey(input.payload),
     nativeSessionId,
-    projectKey: team?.projectKey ?? null,
+    projectKey: team?.projectKey ?? workspace?.projectKey ?? null,
     runId: team?.runId ?? null,
     roleId: team?.roleId ?? null,
-    cwd: optionalString4(input.payload.cwd),
+    cwd,
     discoveredAt: input.now,
     source,
     tracePath: normalizedPath,
@@ -5799,7 +5961,7 @@ function sanitizeCodeAgentTraceRefForWrite(ref) {
   });
 }
 function resolveCodeAgentTraceRefPath(input) {
-  return join7(resolveCodeAgentTraceRefTargetDir(input.homeDir, input.target), `${sanitizePersistentIdentifier2(input.sessionKey, "session")}.json`);
+  return join8(resolveCodeAgentTraceRefTargetDir(input.homeDir, input.target), `${sanitizePersistentIdentifier2(input.sessionKey, "session")}.json`);
 }
 function resolveCodeAgentTraceRefTargetDir(homeDir, target) {
   const paths = resolveCodeAgentTraceRefPaths(homeDir);
@@ -5816,7 +5978,7 @@ function parseTraceRefId(id) {
 }
 async function readDirectoryEntries(dir) {
   try {
-    return await readdir6(dir, { withFileTypes: true });
+    return await readdir7(dir, { withFileTypes: true });
   } catch (error) {
     if (isNotFoundError2(error))
       return [];
@@ -5842,7 +6004,7 @@ function normalizeTracePathForInspection(value, notes) {
     notes.push("trace path omitted: URLs are not stored");
     return null;
   }
-  if (!isAbsolute4(trimmed)) {
+  if (!isAbsolute5(trimmed)) {
     notes.push("trace path omitted: relative paths are not trusted");
     return null;
   }
@@ -5868,7 +6030,7 @@ async function inspectTracePath(input) {
   const notes = [];
   let exists = null;
   try {
-    await stat4(input.tracePath);
+    await stat5(input.tracePath);
     exists = true;
   } catch (error) {
     if (isNotFoundError2(error)) {
@@ -5886,11 +6048,11 @@ async function inspectTracePath(input) {
   return { exists, trusted, notes };
 }
 function resolveTargetUserDir(input) {
-  return normalize(join7(stripTrailingSlash3(input.homeDir), input.target === "claude" ? ".claude" : ".codex"));
+  return normalize(join8(stripTrailingSlash3(input.homeDir), input.target === "claude" ? ".claude" : ".codex"));
 }
 function isDescendant(parent, child) {
   const relation = relative5(normalize(parent), normalize(child));
-  return relation === "" || !relation.startsWith("..") && !isAbsolute4(relation);
+  return relation === "" || !relation.startsWith("..") && !isAbsolute5(relation);
 }
 function hasRawTraversalSegment(path) {
   return path.split(/[/\\]+/).some((part) => part === "..");
@@ -6039,6 +6201,7 @@ __export(exports_session_memory, {
   readSessionCursor: () => readSessionCursor,
   readLineRange: () => readLineRange,
   parseSessionMemoryPolicy: () => parseSessionMemoryPolicy,
+  listSessionMemoryStates: () => listSessionMemoryStates,
   listSessionEvidenceSegments: () => listSessionEvidenceSegments,
   createDefaultSessionMemoryPolicy: () => createDefaultSessionMemoryPolicy,
   appendRawEvent: () => appendRawEvent,
@@ -6046,24 +6209,24 @@ __export(exports_session_memory, {
 });
 
 // packages/core/src/evolution/evidence/session-memory/paths.ts
-import { join as join8 } from "node:path";
+import { join as join9 } from "node:path";
 function resolveSessionMemoryPaths(input) {
-  const rootDir = join8(resolveEvoDevPaths(input.homeDir).stateDir, "session-memory");
+  const rootDir = join9(resolveEvoDevPaths(input.homeDir).stateDir, "session-memory");
   const projectKey = sanitizeStorageId(input.projectKey, "project");
   const sessionKey = sanitizeStorageId(input.sessionKey, "session");
-  const projectDir = join8(rootDir, projectKey);
-  const sessionDir = join8(projectDir, sessionKey);
-  const segmentsDir = join8(sessionDir, "segments");
+  const projectDir = join9(rootDir, projectKey);
+  const sessionDir = join9(projectDir, sessionKey);
+  const segmentsDir = join9(sessionDir, "segments");
   return {
     rootDir,
     projectDir,
     sessionDir,
-    statePath: join8(sessionDir, "state.json"),
-    cursorPath: join8(sessionDir, "cursor.json"),
-    eventsPath: join8(sessionDir, "events.jsonl"),
+    statePath: join9(sessionDir, "state.json"),
+    cursorPath: join9(sessionDir, "cursor.json"),
+    eventsPath: join9(sessionDir, "events.jsonl"),
     segmentsDir,
-    segmentPath: (segmentId) => join8(segmentsDir, `${sanitizeStorageId(segmentId, "segment")}.json`),
-    indexPath: join8(sessionDir, "index.json")
+    segmentPath: (segmentId) => join9(segmentsDir, `${sanitizeStorageId(segmentId, "segment")}.json`),
+    indexPath: join9(sessionDir, "index.json")
   };
 }
 // packages/core/src/evolution/evidence/session-memory/policy.ts
@@ -6093,8 +6256,8 @@ function parseSessionMemoryPolicy(value) {
   };
 }
 // packages/core/src/evolution/evidence/session-memory/storage.ts
-import { appendFile as appendFile2, mkdir as mkdir6, readFile as readFile7, readdir as readdir7, writeFile as writeFile5 } from "node:fs/promises";
-import { dirname as dirname6, join as join9 } from "node:path";
+import { appendFile as appendFile2, mkdir as mkdir6, readFile as readFile8, readdir as readdir8, writeFile as writeFile5 } from "node:fs/promises";
+import { dirname as dirname7, join as join10 } from "node:path";
 
 // packages/core/src/evolution/evidence/session-memory/constants.ts
 var DEFAULT_MAX_RAW_EVENT_BYTES = 64 * 1024;
@@ -6113,8 +6276,8 @@ class SessionMemoryEvidenceError extends Error {
   }
 }
 async function listSessionEvidenceSegments(input) {
-  const rootDir = join9(resolveEvoDevPaths(input.homeDir).stateDir, "session-memory");
-  const projectDirs = input.projectKey === undefined ? await listDirectoryNames2(rootDir) : [input.projectKey];
+  const rootDir = join10(resolveEvoDevPaths(input.homeDir).stateDir, "session-memory");
+  const projectDirs = input.projectKey === undefined ? await listDirectoryNames3(rootDir) : [input.projectKey];
   const segments = [];
   for (const projectKey of projectDirs) {
     const paths = resolveSessionMemoryPaths({
@@ -6122,7 +6285,7 @@ async function listSessionEvidenceSegments(input) {
       projectKey,
       sessionKey: "list"
     });
-    for (const sessionKey of await listDirectoryNames2(paths.projectDir)) {
+    for (const sessionKey of await listDirectoryNames3(paths.projectDir)) {
       const sessionPaths = resolveSessionMemoryPaths({
         homeDir: input.homeDir,
         projectKey,
@@ -6130,17 +6293,33 @@ async function listSessionEvidenceSegments(input) {
       });
       for (const entry of await listJsonFiles(sessionPaths.segmentsDir)) {
         try {
-          segments.push(parseSessionEvidenceSegment(JSON.parse(await readFile7(entry, "utf8"))));
+          segments.push(parseSessionEvidenceSegment(JSON.parse(await readFile8(entry, "utf8"))));
         } catch {}
       }
     }
   }
   return segments.sort((left, right) => right.createdAt.localeCompare(left.createdAt));
 }
+async function listSessionMemoryStates(input) {
+  const rootDir = join10(resolveEvoDevPaths(input.homeDir).stateDir, "session-memory");
+  const projectDirs = input.projectKey === undefined ? await listDirectoryNames3(rootDir) : [input.projectKey];
+  const states = [];
+  for (const projectKey of projectDirs) {
+    const projectDir = join10(rootDir, projectKey);
+    for (const sessionKey of await listDirectoryNames3(projectDir)) {
+      try {
+        const state = parseSessionMemoryState(JSON.parse(await readFile8(join10(projectDir, sessionKey, "state.json"), "utf8")));
+        if (state.projectKey === projectKey && state.sessionKey === sessionKey)
+          states.push(state);
+      } catch {}
+    }
+  }
+  return states.sort((left, right) => right.updatedAt.localeCompare(left.updatedAt) || left.sessionKey.localeCompare(right.sessionKey));
+}
 async function readSessionEvidenceSegment(input) {
   const paths = resolveSessionMemoryPaths(input);
   try {
-    const segment = parseSessionEvidenceSegment(JSON.parse(await readFile7(paths.segmentPath(input.segmentId), "utf8")));
+    const segment = parseSessionEvidenceSegment(JSON.parse(await readFile8(paths.segmentPath(input.segmentId), "utf8")));
     if (segment.id !== input.segmentId || segment.projectKey !== input.projectKey || segment.sessionKey !== input.sessionKey) {
       throw new SessionMemoryEvidenceError("invalid", "Session evidence identity does not match its storage path.");
     }
@@ -6156,7 +6335,7 @@ async function readSessionEvidenceSegment(input) {
 }
 async function readSessionState(path) {
   try {
-    return JSON.parse(await readFile7(path, "utf8"));
+    return JSON.parse(await readFile8(path, "utf8"));
   } catch (error) {
     if (isNotFoundError(error))
       return null;
@@ -6165,7 +6344,7 @@ async function readSessionState(path) {
 }
 async function readSessionCursor(path, sessionKey, sourcePath, now) {
   try {
-    return JSON.parse(await readFile7(path, "utf8"));
+    return JSON.parse(await readFile8(path, "utf8"));
   } catch (error) {
     if (!isNotFoundError(error))
       throw error;
@@ -6184,13 +6363,13 @@ async function readSessionCursor(path, sessionKey, sourcePath, now) {
 }
 async function appendRawEvent(path, event) {
   const existingLineCount = await countJsonlLines(path);
-  await mkdir6(dirname6(path), { recursive: true });
+  await mkdir6(dirname7(path), { recursive: true });
   await appendFile2(path, `${JSON.stringify(event)}
 `, "utf8");
   return { lineNumber: existingLineCount + 1 };
 }
 async function readLineRange(path, fromLine, toLine) {
-  const text2 = await readFile7(path, "utf8");
+  const text2 = await readFile8(path, "utf8");
   const lines = text2.split(`
 `).filter((line) => line.trim() !== "");
   const selected = lines.slice(Math.max(0, fromLine - 1), toLine);
@@ -6229,13 +6408,13 @@ async function writeSessionIndex(paths, state, segment, now) {
   });
 }
 async function writeJson2(path, value) {
-  await mkdir6(dirname6(path), { recursive: true });
+  await mkdir6(dirname7(path), { recursive: true });
   await writeFile5(path, `${JSON.stringify(value, null, 2)}
 `, "utf8");
 }
 async function countJsonlLines(path) {
   try {
-    const text2 = await readFile7(path, "utf8");
+    const text2 = await readFile8(path, "utf8");
     return text2.split(`
 `).filter((line) => line.trim() !== "").length;
   } catch (error) {
@@ -6246,7 +6425,7 @@ async function countJsonlLines(path) {
 }
 async function readSessionIndex(path) {
   try {
-    const parsed = JSON.parse(await readFile7(path, "utf8"));
+    const parsed = JSON.parse(await readFile8(path, "utf8"));
     if (!Array.isArray(parsed.segments))
       return { segments: [] };
     return {
@@ -6274,9 +6453,19 @@ function parseSessionEvidenceSegment(value) {
   }
   return segment;
 }
-async function listDirectoryNames2(path) {
+function parseSessionMemoryState(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new SessionMemoryEvidenceError("invalid", "Session Memory state must be an object.");
+  }
+  const state = value;
+  if (state.schemaVersion !== 1 || state.kind !== "session-memory-state" || typeof state.projectKey !== "string" || typeof state.sessionKey !== "string" || !(state.runId === null || typeof state.runId === "string") || !(state.roleId === null || typeof state.roleId === "string") || typeof state.createdAt !== "string" || typeof state.updatedAt !== "string" || typeof state.counters !== "object" || state.counters === null) {
+    throw new SessionMemoryEvidenceError("invalid", "Session Memory state fields are invalid.");
+  }
+  return state;
+}
+async function listDirectoryNames3(path) {
   try {
-    return (await readdir7(path, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
+    return (await readdir8(path, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
   } catch (error) {
     if (isNotFoundError(error))
       return [];
@@ -6285,7 +6474,7 @@ async function listDirectoryNames2(path) {
 }
 async function listJsonFiles(path) {
   try {
-    return (await readdir7(path, { withFileTypes: true })).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => join9(path, entry.name)).sort();
+    return (await readdir8(path, { withFileTypes: true })).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => join10(path, entry.name)).sort();
   } catch (error) {
     if (isNotFoundError(error))
       return [];
@@ -6293,7 +6482,7 @@ async function listJsonFiles(path) {
   }
 }
 // packages/core/src/evolution/evidence/session-memory/updater.ts
-import { join as join11 } from "node:path";
+import { join as join12 } from "node:path";
 
 // packages/core/src/evolution/triggers/index.ts
 var exports_triggers = {};
@@ -6308,8 +6497,8 @@ __export(exports_triggers, {
   enqueueSegmentEvolutionTrigger: () => enqueueSegmentEvolutionTrigger,
   enqueueEvolutionTrigger: () => enqueueEvolutionTrigger
 });
-import { readFile as readFile8 } from "node:fs/promises";
-import { join as join10 } from "node:path";
+import { readFile as readFile9 } from "node:fs/promises";
+import { join as join11 } from "node:path";
 
 // packages/core/src/evolution/triggers/classification.ts
 function normalizeEvolutionEventType(value) {
@@ -6444,19 +6633,19 @@ async function enqueueEvolutionTrigger(input) {
   };
   validateEvolutionTriggerRecord(trigger);
   const paths = resolveEvolutionPaths({ homeDir: input.homeDir, projectKey, runId });
-  await writeJsonFile(join10(paths.triggersDir, `${trigger.id}.json`), trigger, { overwrite: false });
+  await writeJsonFile(join11(paths.triggersDir, `${trigger.id}.json`), trigger, { overwrite: false });
   return trigger;
 }
 async function listEvolutionTriggers(input) {
   const paths = resolveEvoDevPaths(input.homeDir);
-  const evolutionStateDir = join10(paths.stateDir, "evolution");
+  const evolutionStateDir = join11(paths.stateDir, "evolution");
   const projectKeys = input.projectKey === undefined ? await listDirectoryNames(evolutionStateDir) : [sanitizeStorageId2("projectKey", input.projectKey)];
   const triggers = [];
   for (const projectKey of projectKeys) {
-    const projectStateDir = join10(evolutionStateDir, projectKey);
+    const projectStateDir = join11(evolutionStateDir, projectKey);
     const runIds = input.runId === undefined ? await listDirectoryNames(projectStateDir) : [sanitizeStorageId2("runId", input.runId)];
     for (const runId of runIds) {
-      const runTriggers = await readJsonFiles(join10(projectStateDir, runId, "triggers"), parseTrigger);
+      const runTriggers = await readJsonFiles(join11(projectStateDir, runId, "triggers"), parseTrigger);
       triggers.push(...runTriggers.filter((trigger) => input.status === undefined || trigger.status === input.status));
     }
   }
@@ -6497,16 +6686,16 @@ async function enqueueSegmentEvolutionTrigger(input) {
   } catch (error) {
     if (!isFileExistsError(error))
       throw error;
-    return parseSegmentTrigger(JSON.parse(await readFile8(path, "utf8")));
+    return parseSegmentTrigger(JSON.parse(await readFile9(path, "utf8")));
   }
 }
 async function listSegmentEvolutionTriggers(input) {
   const paths = resolveEvoDevPaths(input.homeDir);
-  const evolutionStateDir = join10(paths.stateDir, "evolution");
+  const evolutionStateDir = join11(paths.stateDir, "evolution");
   const projectKeys = input.projectKey === undefined ? await listDirectoryNames(evolutionStateDir) : [sanitizeStorageId2("projectKey", input.projectKey)];
   const triggers = [];
   for (const projectKey of projectKeys) {
-    const projectSegmentsDir = join10(evolutionStateDir, projectKey, "segments");
+    const projectSegmentsDir = join11(evolutionStateDir, projectKey, "segments");
     const projectTriggers = await readJsonFiles(projectSegmentsDir, parseSegmentTrigger);
     triggers.push(...projectTriggers.filter((trigger) => {
       if (input.status !== undefined && trigger.status !== input.status)
@@ -6543,7 +6732,7 @@ async function updateTriggers(homeDir, triggers, patch) {
       projectKey: next.projectKey,
       runId: next.runId
     });
-    await writeJsonFile(join10(paths.triggersDir, `${next.id}.json`), next, { overwrite: true });
+    await writeJsonFile(join11(paths.triggersDir, `${next.id}.json`), next, { overwrite: true });
   }
 }
 async function updateSegmentTriggers(homeDir, triggers, patch) {
@@ -6562,7 +6751,7 @@ async function updateSegmentTriggers(homeDir, triggers, patch) {
 }
 function resolveSegmentEvolutionTriggerPath(homeDir, trigger) {
   const paths = resolveEvoDevPaths(homeDir);
-  return join10(paths.stateDir, "evolution", sanitizeStorageId2("projectKey", trigger.projectKey), "segments", `${sanitizeStorageId2("segmentTrigger", trigger.id)}.json`);
+  return join11(paths.stateDir, "evolution", sanitizeStorageId2("projectKey", trigger.projectKey), "segments", `${sanitizeStorageId2("segmentTrigger", trigger.id)}.json`);
 }
 
 // packages/core/src/evolution/evidence/session-memory/segment.ts
@@ -6877,7 +7066,9 @@ async function updateSessionMemoryFromHook(input) {
     environment: input.environment,
     payload: input.rawPayload
   });
-  const projectKey = sanitizeStorageId(team?.projectKey ?? resolveProjectLogKey(input.homeDir, optionalString(input.rawPayload.cwd) ?? input.homeDir), "project");
+  const cwd = optionalString(input.rawPayload.cwd);
+  const workspace = team === null && cwd !== null ? await resolveProjectWorkspaceFromCwd({ homeDir: input.homeDir, cwd }) : null;
+  const projectKey = sanitizeStorageId(team?.projectKey ?? workspace?.projectKey ?? resolveProjectLogKey(input.homeDir, cwd ?? input.homeDir), "project");
   const sessionKey = sanitizeStorageId(resolveTraceSessionKey(input.rawPayload), "session");
   const paths = resolveSessionMemoryPaths({ homeDir: input.homeDir, projectKey, sessionKey });
   const now = normalizeTimestamp(input.receivedAt ?? input.event.time.receivedAt);
@@ -6971,7 +7162,7 @@ async function updateSessionMemoryFromHook(input) {
   await writeJson2(paths.cursorPath, cursor);
   stateWrites.push(paths.statePath, paths.cursorPath);
   if (queuedSegmentTriggerId !== null) {
-    stateWrites.push(join11(input.homeDir, ".evodev", "state", "evolution", projectKey, "segments", `${queuedSegmentTriggerId}.json`));
+    stateWrites.push(join12(input.homeDir, ".evodev", "state", "evolution", projectKey, "segments", `${queuedSegmentTriggerId}.json`));
   }
   return {
     state,
@@ -6993,577 +7184,13 @@ function emptyResult() {
   };
 }
 // packages/core/src/hooks/index.ts
-import { mkdir as mkdir9, readFile as readFile11, writeFile as writeFile8 } from "node:fs/promises";
+import { mkdir as mkdir8, readFile as readFile11, writeFile as writeFile7 } from "node:fs/promises";
 import { dirname as dirname9, join as join14 } from "node:path";
 
-// packages/core/src/task/index.ts
-import { lstat, mkdir as mkdir7, readFile as readFile9, realpath, stat as stat5, writeFile as writeFile6 } from "node:fs/promises";
-import { basename, dirname as dirname7, join as join12, resolve as resolve3 } from "node:path";
-var FORBIDDEN_TASK_PATHS = ["CLAUDE.md", "AGENTS.md", ".claude/**", ".codex/**"];
-var FORBIDDEN_TASK_WRITE_SEGMENTS = new Set([".claude", ".codex"]);
-var FORBIDDEN_PROJECT_ASSET_SEGMENTS = new Set(["packages", "src"]);
-var FORBIDDEN_TASK_WRITE_FILES = new Set(["agents.md", "claude.md", "package.json", "readme.md"]);
-var FORBIDDEN_RAW_KEYS2 = new Set([
-  "rawoutput",
-  "raw_output",
-  "stdout",
-  "stderr",
-  "source",
-  "sourcecontent",
-  "source_content",
-  "sourcetext",
-  "source_text",
-  "prompt",
-  "prompttext",
-  "prompt_text",
-  "transcript",
-  "transcripttext",
-  "transcript_text",
-  "secret",
-  "secretvalue",
-  "secret_value"
-]);
-var ALLOWED_VERIFICATION_KEYS = new Set([
-  "acceptanceResults",
-  "antiCriteriaResults",
-  "commands",
-  "evidence",
-  "exitCode",
-  "id",
-  "status",
-  "summary",
-  "type"
-]);
-var SENSITIVE_TEXT_PATTERN3 = /https?:\/\/\S+|\b(secret|token|password|passwd|private|internal|api[_-]?key|apikey|credential|credentials|raw log|raw source|raw prompt)\b/gi;
-function createTaskContract(input) {
-  const taskId = createTaskId(input.title);
-  const summary = input.summary ?? input.title;
-  const acceptanceCriteria = input.acceptanceCriteria === undefined || input.acceptanceCriteria.length === 0 ? [
-    {
-      id: "AC1",
-      category: "engineering",
-      statement: "Task outcome satisfies the requested target state.",
-      requiredEvidence: ["verification-summary"],
-      status: "not-run"
-    }
-  ] : input.acceptanceCriteria.map((criterion) => ({
-    id: sanitizeId2(criterion.id),
-    category: criterion.category,
-    statement: sanitizeText2(criterion.statement),
-    requiredEvidence: uniqueSanitizedIds2(criterion.requiredEvidence ?? []),
-    status: "not-run"
-  }));
-  const defaultAntiCriteria = [
-    {
-      id: "ANTI1",
-      category: "privacy",
-      statement: "Do not collect source code, prompts, raw command output, secrets, or internal links.",
-      status: "unknown"
-    },
-    {
-      id: "ANTI2",
-      category: "scope",
-      statement: "Do not write outside approved task storage or approved implementation scope.",
-      status: "unknown"
-    }
-  ];
-  return {
-    version: 1,
-    taskId,
-    status: "draft",
-    classification: "local-private",
-    source: { summary: sanitizeText2(summary), rawPromptStored: false },
-    context: {
-      projectId: input.projectId === undefined || input.projectId === null ? null : sanitizeText2(input.projectId),
-      relatedFiles: [],
-      assumptions: [],
-      openQuestions: []
-    },
-    currentState: { summary: "To be completed by the task owner.", evidenceRefs: [] },
-    targetState: { summary: sanitizeText2(input.title), nonGoals: [], constraints: [] },
-    scope: {
-      allowedPaths: sanitizeTextList(input.allowedPaths ?? []),
-      forbiddenPaths: FORBIDDEN_TASK_PATHS,
-      allowedOperations: input.allowedOperations === undefined || input.allowedOperations.length === 0 ? ["read", "edit-approved-files", "run-local-tests"] : sanitizeTextList(input.allowedOperations),
-      requiresUserConfirmation: sanitizeTextList(input.requiresUserConfirmation ?? [])
-    },
-    acceptanceCriteria,
-    antiCriteria: [
-      ...defaultAntiCriteria,
-      ...(input.antiCriteria ?? []).map((criterion) => ({
-        id: sanitizeId2(criterion.id),
-        category: criterion.category,
-        statement: sanitizeText2(criterion.statement),
-        status: "unknown"
-      }))
-    ],
-    route: {
-      mode: null,
-      workflowId: null,
-      rationale: "Not routed yet.",
-      requiredReview: [],
-      requiredVerification: uniqueSanitizedIds2(input.requiredVerification ?? [])
-    },
-    verification: {
-      policy: "advisory",
-      commands: [],
-      acceptanceResults: [],
-      antiCriteriaResults: [],
-      status: "not-run",
-      summary: "Verification has not run."
-    },
-    evidence: { metadataOnly: true, items: [] },
-    learningCandidates: []
-  };
-}
-function routeTaskContract(contract) {
-  const mode = selectMode(contract);
-  const requiredVerification = uniqueSanitizedIds2([
-    ...contract.route.requiredVerification ?? [],
-    "verification-summary"
-  ]);
-  return {
-    ...contract,
-    status: "routed",
-    route: {
-      mode,
-      workflowId: selectWorkflowId(contract, mode),
-      rationale: createRouteRationale(contract, mode),
-      requiredReview: mode === "rigorous" ? ["security-boundary", "verification"] : [],
-      requiredVerification
-    }
-  };
-}
-function verifyTaskContract(contract, input) {
-  assertMetadataOnly(input);
-  const commands = (input.commands ?? []).map((command) => ({
-    id: sanitizeId2(command.id),
-    status: assertVerificationCommandStatus(command.status, `command ${command.id}`),
-    exitCode: command.exitCode,
-    summary: sanitizeText2(command.summary ?? `${command.id}: ${command.status}`),
-    rawOutputStored: false
-  }));
-  const acceptanceResults = (input.acceptanceResults ?? []).map((result) => ({
-    id: sanitizeId2(result.id),
-    status: assertAcceptanceResultStatus(result.status, `acceptance ${result.id}`),
-    summary: sanitizeText2(result.summary ?? `${result.id}: ${result.status}`)
-  }));
-  const antiCriteriaResults = (input.antiCriteriaResults ?? []).map((result) => ({
-    id: sanitizeId2(result.id),
-    status: assertAntiCriteriaResultStatus(result.status, `anti-criteria ${result.id}`),
-    summary: sanitizeText2(result.summary ?? `${result.id}: ${result.status}`)
-  }));
-  const evidence = (input.evidence ?? []).map((item) => ({
-    type: assertEvidenceType(item.type, `evidence ${item.id}`),
-    id: sanitizeId2(item.id),
-    status: assertVerificationStatus(item.status, `evidence ${item.id}`),
-    summary: sanitizeText2(item.summary ?? `${item.id}: ${item.status}`),
-    rawOutputStored: false,
-    sourceContentStored: false
-  }));
-  const failures = collectVerificationFailures(contract, commands, acceptanceResults, antiCriteriaResults, evidence);
-  const ok = failures.length === 0;
-  const summary = ok ? "Verification passed." : `Verification failed: ${failures.join("; ")}`;
-  return {
-    ok,
-    summary,
-    contract: {
-      ...contract,
-      status: ok ? "verified" : "failed",
-      acceptanceCriteria: contract.acceptanceCriteria.map((criterion) => ({
-        ...criterion,
-        status: acceptanceResults.find((result) => result.id === criterion.id)?.status ?? criterion.status
-      })),
-      antiCriteria: contract.antiCriteria.map((criterion) => ({
-        ...criterion,
-        status: antiCriteriaResults.find((result) => result.id === criterion.id)?.status ?? criterion.status
-      })),
-      verification: {
-        policy: "advisory",
-        commands,
-        acceptanceResults,
-        antiCriteriaResults,
-        status: ok ? "pass" : "fail",
-        summary
-      },
-      evidence: {
-        metadataOnly: true,
-        items: evidence
-      }
-    }
-  };
-}
-async function readTaskContract(path) {
-  return parseTaskContract(JSON.parse(await readFile9(path, "utf8")));
-}
-async function writeTaskContract(path, contract, options = {}) {
-  await assertTaskContractWritePathAllowed(path);
-  await mkdir7(dirname7(path), { recursive: true });
-  await writeFile6(path, `${JSON.stringify(contract, null, 2)}
-`, {
-    encoding: "utf8",
-    flag: options.overwrite === true ? "w" : "wx"
-  });
-}
-async function resolveTaskContractOutputPath(input) {
-  if (input.outputDir !== undefined) {
-    const outputPath = join12(input.outputDir, input.taskId, "contract.json");
-    await assertTaskContractWritePathAllowed(outputPath);
-    return outputPath;
-  }
-  if (input.projectDir !== undefined) {
-    const projectContextPath = join12(input.projectDir, ".evodev", "project.json");
-    if (!await pathExists4(projectContextPath)) {
-      throw new Error("Project mode requires existing .evodev/project.json; use --output-dir instead.");
-    }
-    const outputPath = join12(input.projectDir, ".evodev", "tasks", input.taskId, "contract.json");
-    await assertTaskContractWritePathAllowed(outputPath);
-    return outputPath;
-  }
-  throw new Error("Task writes require --output-dir or --project-dir with existing project context.");
-}
-function formatTaskContract(contract) {
-  return [
-    "EvoDev task contract",
-    "",
-    `Task id: ${contract.taskId}`,
-    `Status: ${contract.status}`,
-    `Summary: ${contract.source.summary}`,
-    `Mode: ${contract.route.mode ?? "not routed"}`,
-    `Workflow: ${contract.route.workflowId ?? "not routed"}`,
-    `Required verification: ${formatList(contract.route.requiredVerification)}`,
-    `Required review: ${formatList(contract.route.requiredReview)}`,
-    `Route rationale: ${contract.route.rationale}`,
-    `Verification: ${contract.verification.status}`,
-    `Verification summary: ${contract.verification.summary}`
-  ].join(`
-`);
-}
-function selectMode(contract) {
-  if (selectRigorousTrigger(contract) !== null) {
-    return "rigorous";
-  }
-  const allowedPaths = contract.scope.allowedPaths ?? [];
-  if (allowedPaths.length <= 1 && contract.acceptanceCriteria.length <= 1) {
-    return "minimal";
-  }
-  return "standard";
-}
-function selectWorkflowId(contract, mode) {
-  const text2 = collectRouteText(contract);
-  if (text2.includes("release") || text2.includes("publish"))
-    return "rd-release-readiness";
-  if (hasSecurityBoundaryTerms(text2) || mode === "rigorous") {
-    return "rd-security-boundary-review";
-  }
-  if (text2.includes("bug"))
-    return "rd-bug-fix";
-  if (text2.includes("refactor"))
-    return "rd-refactor";
-  if (text2.includes("review"))
-    return "rd-code-review";
-  if (text2.includes("doc"))
-    return "rd-docs-update";
-  if (text2.includes("test"))
-    return "rd-test-generation";
-  if (mode === "minimal")
-    return "rd-docs-update";
-  return "rd-feature-implementation";
-}
-function collectRouteText(contract) {
-  return [
-    contract.taskId,
-    contract.source.summary,
-    contract.currentState.summary,
-    ...contract.currentState.evidenceRefs,
-    contract.targetState.summary,
-    ...contract.targetState.nonGoals,
-    ...contract.targetState.constraints,
-    ...contract.context.relatedFiles.map((file) => `${file.path} ${file.reason}`),
-    ...contract.context.assumptions,
-    ...contract.context.openQuestions,
-    ...contract.scope.allowedPaths ?? [],
-    ...contract.scope.allowedOperations ?? [],
-    ...contract.scope.requiresUserConfirmation ?? [],
-    ...contract.acceptanceCriteria.map((criterion) => criterion.statement),
-    ...contract.acceptanceCriteria.flatMap((criterion) => criterion.requiredEvidence),
-    ...contract.route.requiredVerification ?? []
-  ].join(" ").toLowerCase();
-}
-function createRouteRationale(contract, mode) {
-  const trigger = selectRigorousTrigger(contract);
-  if (mode === "rigorous")
-    return `Selected rigorous due to ${trigger ?? "high-risk"} trigger.`;
-  if (mode === "minimal")
-    return "Selected minimal for narrow scope and simple acceptance criteria.";
-  return "Selected standard for bounded engineering work requiring Task Contract verification.";
-}
-function selectRigorousTrigger(contract) {
-  const text2 = collectRouteText(contract);
-  if (text2.includes("[redacted]") || hasSecurityBoundaryTerms(text2))
-    return "privacy/security";
-  if (/\b(release|publish|publishing|package distribution|npm publish)\b/.test(text2)) {
-    return "release/publish";
-  }
-  if (/\b(hook|hooks|learning|memory|telemetry|observability)\b/.test(text2)) {
-    return "hook/learning/telemetry";
-  }
-  if (/\b(migration|migrate|hard to rollback|hard-to-rollback|irreversible|destructive)\b/.test(text2)) {
-    return "hard-to-rollback";
-  }
-  if (hasHighRiskOperationTerms(text2)) {
-    return "high-risk operation";
-  }
-  if ((contract.scope.requiresUserConfirmation ?? []).length > 0) {
-    return "explicit user confirmation";
-  }
-  for (const path of contract.scope.allowedPaths ?? []) {
-    const trigger = selectRigorousPathTrigger(path);
-    if (trigger !== null)
-      return trigger;
-  }
-  for (const operation of contract.scope.allowedOperations ?? []) {
-    if (hasHighRiskOperationTerms(operation))
-      return "high-risk operation";
-  }
-  return null;
-}
-function hasSecurityBoundaryTerms(text2) {
-  return /\b(security|privacy|private data|auth|authentication|authorization|credential|credentials|secret|secrets|token|tokens|api key|api-key|apikey|password|passwd)\b/.test(text2);
-}
-function selectRigorousPathTrigger(path) {
-  const normalized = path.trim().replace(/\\/g, "/").toLowerCase();
-  if (/^~\/\.(evodev|claude|codex)(\/|$)/.test(normalized)) {
-    return "user-level Code Agent/EvoDev path";
-  }
-  if (normalized === ".evodev" || normalized.startsWith(".evodev/") || normalized.includes("/.evodev/")) {
-    return "project .evodev path";
-  }
-  if (normalized === ".claude" || normalized.startsWith(".claude/") || normalized.includes("/.claude/") || normalized === ".codex" || normalized.startsWith(".codex/") || normalized.includes("/.codex/")) {
-    return "project Code Agent config path";
-  }
-  const fileName = basename(normalized);
-  if (fileName === "claude.md" || fileName === "agents.md")
-    return "agent instruction file";
-  return null;
-}
-function hasHighRiskOperationTerms(text2) {
-  const normalized = text2.toLowerCase().replace(/[_-]+/g, " ");
-  return /\b(delete|remove|publish|release|install|uninstall|network|external|external service|external api|write user config|user config|write project context|project context|hook|learning|memory|telemetry)\b/.test(normalized);
-}
-function collectVerificationFailures(contract, commands, acceptanceResults, antiCriteriaResults, evidence) {
-  const failures = [];
-  if (!isVerificationReady(contract)) {
-    failures.push("task contract must be routed before verification");
-  }
-  failures.push(...collectDuplicateIdFailures("command", commands));
-  failures.push(...collectDuplicateIdFailures("evidence", evidence));
-  failures.push(...collectDuplicateIdFailures("acceptance result", acceptanceResults));
-  failures.push(...collectDuplicateIdFailures("anti-criteria result", antiCriteriaResults));
-  for (const requiredId of contract.route.requiredVerification ?? []) {
-    const matches = [
-      ...commands.filter((command) => command.id === requiredId),
-      ...evidence.filter((item) => item.id === requiredId)
-    ];
-    if (matches.length === 0) {
-      failures.push(`missing required verification: ${requiredId}`);
-      continue;
-    }
-    if (matches.some((item) => !isSatisfyingVerificationItem(item))) {
-      failures.push(`required verification ${requiredId} is not satisfied`);
-    }
-  }
-  for (const criterion of contract.acceptanceCriteria) {
-    const result = acceptanceResults.find((candidate) => candidate.id === criterion.id);
-    if (result === undefined || result.status !== "pass" && result.status !== "not-applicable") {
-      failures.push(`acceptance ${criterion.id} is not satisfied`);
-    }
-    for (const evidenceId of criterion.requiredEvidence) {
-      const matches = evidence.filter((item) => item.id === evidenceId);
-      if (matches.length === 0) {
-        failures.push(`missing evidence for ${criterion.id}: ${evidenceId}`);
-        continue;
-      }
-      if (matches.some((item) => !isSatisfyingEvidenceItem(item))) {
-        failures.push(`evidence for ${criterion.id} is not satisfied: ${evidenceId}`);
-      }
-    }
-  }
-  for (const criterion of contract.antiCriteria) {
-    const result = antiCriteriaResults.find((candidate) => candidate.id === criterion.id);
-    if (result === undefined || result.status === "unknown" || result.status === "triggered") {
-      failures.push(`anti-criteria ${criterion.id} is not clear`);
-    }
-  }
-  return failures;
-}
-function collectDuplicateIdFailures(label, items) {
-  const seen = new Set;
-  const duplicates = new Set;
-  for (const item of items) {
-    if (seen.has(item.id))
-      duplicates.add(item.id);
-    seen.add(item.id);
-  }
-  return Array.from(duplicates).map((id) => `duplicate ${label} id: ${id}`);
-}
-function isSatisfyingVerificationItem(item) {
-  if ("rawOutputStored" in item && "type" in item)
-    return isSatisfyingEvidenceItem(item);
-  return item.status === "pass";
-}
-function isSatisfyingEvidenceItem(item) {
-  if (item.type === "command-result")
-    return item.status === "pass";
-  return item.status === "pass" || item.status === "clear";
-}
-function isVerificationReady(contract) {
-  return contract.status !== "draft" && contract.route.mode !== null && contract.route.workflowId !== null && (contract.route.requiredVerification ?? []).length > 0;
-}
-function parseTaskContract(value) {
-  if (!isRecord7(value) || value.version !== 1 || typeof value.taskId !== "string") {
-    throw new Error("Invalid Task Contract JSON.");
-  }
-  return value;
-}
-function assertMetadataOnly(value) {
-  if (Array.isArray(value)) {
-    for (const item of value)
-      assertMetadataOnly(item);
-    return;
-  }
-  if (!isRecord7(value)) {
-    if (typeof value === "string" && containsSensitiveText(value)) {
-      throw new Error("Verification input contains sensitive content in metadata field.");
-    }
-    return;
-  }
-  for (const [key, child] of Object.entries(value)) {
-    const normalizedKey = key.toLowerCase().replace(/[^a-z0-9]/g, "");
-    if (FORBIDDEN_RAW_KEYS2.has(key) || FORBIDDEN_RAW_KEYS2.has(normalizedKey)) {
-      throw new Error(`Verification input contains forbidden raw field: ${key}`);
-    }
-    if (!ALLOWED_VERIFICATION_KEYS.has(key)) {
-      throw new Error(`Verification input contains unsupported field: ${key}`);
-    }
-    assertMetadataOnly(child);
-  }
-}
-function assertVerificationCommandStatus(value, label) {
-  if (value === "pass" || value === "fail" || value === "not-run")
-    return value;
-  throw new Error(`Invalid verification command status for ${label}: ${String(value)}`);
-}
-function assertAcceptanceResultStatus(value, label) {
-  if (value === "pass" || value === "fail" || value === "not-run" || value === "not-applicable") {
-    return value;
-  }
-  throw new Error(`Invalid acceptance result status for ${label}: ${String(value)}`);
-}
-function assertAntiCriteriaResultStatus(value, label) {
-  if (value === "clear" || value === "triggered" || value === "unknown")
-    return value;
-  throw new Error(`Invalid anti-criteria result status for ${label}: ${String(value)}`);
-}
-function assertVerificationStatus(value, label) {
-  if (value === "pass" || value === "fail" || value === "not-run" || value === "not-applicable" || value === "unknown" || value === "triggered" || value === "clear") {
-    return value;
-  }
-  throw new Error(`Invalid verification status for ${label}: ${String(value)}`);
-}
-function assertEvidenceType(value, label) {
-  if (value === "command-result" || value === "manual-check" || value === "review")
-    return value;
-  throw new Error(`Invalid evidence type for ${label}: ${String(value)}`);
-}
-function sanitizeText2(value) {
-  return value.replace(SENSITIVE_TEXT_PATTERN3, "[redacted]").slice(0, 500);
-}
-function containsSensitiveText(value) {
-  SENSITIVE_TEXT_PATTERN3.lastIndex = 0;
-  return SENSITIVE_TEXT_PATTERN3.test(value);
-}
-async function assertTaskContractWritePathAllowed(path) {
-  assertTaskContractWritePathSegmentsAllowed(resolve3(path));
-  assertTaskContractWritePathSegmentsAllowed(await resolveTaskWriteRealPath(path));
-}
-function assertTaskContractWritePathSegmentsAllowed(path) {
-  const segments = path.replace(/\\/g, "/").split("/").filter((segment) => segment.length > 0).map((segment) => segment.toLowerCase());
-  const protectedSegment = segments.find((segment) => FORBIDDEN_TASK_WRITE_SEGMENTS.has(segment));
-  if (protectedSegment !== undefined) {
-    throw new Error(`Task contract write path is protected: ${protectedSegment}`);
-  }
-  if (!isTaskStoragePath(segments)) {
-    const protectedProjectAssetSegment = segments.find((segment) => FORBIDDEN_PROJECT_ASSET_SEGMENTS.has(segment));
-    if (protectedProjectAssetSegment !== undefined) {
-      throw new Error(`Task contract write path is protected: ${protectedProjectAssetSegment}`);
-    }
-  }
-  const protectedFile = segments.find((segment) => FORBIDDEN_TASK_WRITE_FILES.has(segment));
-  if (protectedFile !== undefined) {
-    throw new Error(`Task contract write path is protected: ${protectedFile}`);
-  }
-}
-async function resolveTaskWriteRealPath(path) {
-  let currentPath = resolve3(path);
-  const missingSegments = [];
-  while (true) {
-    try {
-      await lstat(currentPath);
-      return join12(await realpath(currentPath), ...missingSegments.reverse());
-    } catch (error) {
-      if (!isMissingPathError(error))
-        throw error;
-      const parentPath = dirname7(currentPath);
-      if (parentPath === currentPath)
-        return resolve3(path);
-      missingSegments.push(basename(currentPath));
-      currentPath = parentPath;
-    }
-  }
-}
-function isTaskStoragePath(segments) {
-  return segments.some((segment, index) => segment === ".evodev" && (segments[index + 1] === "tasks" || segments[index + 1] === "state" && segments[index + 2] === "tasks"));
-}
-function sanitizeTextList(values) {
-  return values.map((value) => sanitizeText2(value)).filter((value) => value.length > 0);
-}
-function sanitizeId2(value) {
-  const sanitized = sanitizeText2(value).replace(/\[redacted\]/gi, "redacted").replace(/[^a-zA-Z0-9._-]/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "").slice(0, 80);
-  return sanitized || "item";
-}
-function uniqueSanitizedIds2(values) {
-  return Array.from(new Set(values.map((value) => sanitizeId2(value))));
-}
-function formatList(values) {
-  return values.length === 0 ? "none" : values.join(", ");
-}
-function createTaskId(title) {
-  const slug = sanitizeId2(title.toLowerCase()) || "task";
-  return `task-${slug}`.slice(0, 80);
-}
-async function pathExists4(path) {
-  try {
-    await stat5(path);
-    return true;
-  } catch (error) {
-    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
-      return false;
-    }
-    throw error;
-  }
-}
-function isMissingPathError(error) {
-  return error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR");
-}
-function isRecord7(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
 // packages/core/src/team/index.ts
 import { spawn } from "node:child_process";
-import { appendFile as appendFile3, cp, mkdir as mkdir8, readFile as readFile10, readdir as readdir8, stat as stat6, writeFile as writeFile7 } from "node:fs/promises";
-import { basename as basename2, dirname as dirname8, extname, isAbsolute as isAbsolute5, join as join13, relative as relative6, resolve as resolve4 } from "node:path";
+import { appendFile as appendFile3, cp, mkdir as mkdir7, readFile as readFile10, readdir as readdir9, stat as stat6, writeFile as writeFile6 } from "node:fs/promises";
+import { basename as basename2, dirname as dirname8, extname, isAbsolute as isAbsolute6, join as join13, relative as relative6, resolve as resolve3 } from "node:path";
 
 // packages/core/src/team/prompts.ts
 var TEAM_ROLE_STARTUP_PROMPT_TEMPLATE = [
@@ -7764,8 +7391,8 @@ function createTeamRunStore(homeDir) {
     paths: paths2,
     async createRunDirs(runId) {
       await migrateLegacyRunDirIfNeeded(paths2, runId);
-      await mkdir8(paths2.runDir(runId), { recursive: true });
-      await mkdir8(paths2.agentsDir(runId), { recursive: true });
+      await mkdir7(paths2.runDir(runId), { recursive: true });
+      await mkdir7(paths2.agentsDir(runId), { recursive: true });
     },
     async writeRun(run) {
       await this.createRunDirs(run.runId);
@@ -7776,7 +7403,7 @@ function createTeamRunStore(homeDir) {
       return parseTeamRunRecord(JSON.parse(await readFile10(paths2.runPath(runId), "utf8")));
     },
     async writeLatestRunId(runId) {
-      await mkdir8(paths2.runsDir, { recursive: true });
+      await mkdir7(paths2.runsDir, { recursive: true });
       await writeJson3(paths2.latestRunPath, { version: 1, runId });
     },
     async readLatestRunId() {
@@ -7810,7 +7437,7 @@ function createTeamRunStore(homeDir) {
     async readAgents(runId) {
       await migrateLegacyRunDirIfNeeded(paths2, runId);
       try {
-        const entries = await readdir8(paths2.agentsDir(runId));
+        const entries = await readdir9(paths2.agentsDir(runId));
         const agents = await Promise.all(entries.filter((entry) => entry.endsWith(".json")).map((entry) => readFile10(join13(paths2.agentsDir(runId), entry), "utf8").then((raw) => parseTeamAgentRecord(JSON.parse(raw)))));
         return agents.sort((left, right) => left.roleId.localeCompare(right.roleId));
       } catch {
@@ -7895,12 +7522,12 @@ function resolveTeamRunPaths(homeDir) {
 }
 async function migrateLegacyRunDirIfNeeded(paths2, runId) {
   const nextDir = paths2.runDir(runId);
-  if (await pathExists5(nextDir))
+  if (await pathExists4(nextDir))
     return;
   const legacyDir = paths2.legacyRunDir(runId);
-  if (!await pathExists5(legacyDir))
+  if (!await pathExists4(legacyDir))
     return;
-  await mkdir8(dirname8(nextDir), { recursive: true });
+  await mkdir7(dirname8(nextDir), { recursive: true });
   await cp(legacyDir, nextDir, { recursive: true, errorOnExist: false, force: false });
 }
 async function writeTeamStatusSnapshot(input) {
@@ -8430,7 +8057,7 @@ async function listTeamRuns(input = {}) {
   const entries = new Set;
   for (const runsDir of [store.paths.runsDir, store.paths.legacyRunsDir]) {
     try {
-      for (const entry of await readdir8(runsDir))
+      for (const entry of await readdir9(runsDir))
         entries.add(entry);
     } catch (error) {
       if (!isNotFoundError3(error))
@@ -8763,7 +8390,7 @@ async function listTeamAgents(input = {}) {
 }
 async function resolveTeamOverlay(input) {
   const repoTeamPath = join13(input.repoRoot, ".evodev", "team", "team.md");
-  if (await pathExists5(repoTeamPath)) {
+  if (await pathExists4(repoTeamPath)) {
     return {
       source: "repo",
       teamPath: repoTeamPath,
@@ -8771,7 +8398,7 @@ async function resolveTeamOverlay(input) {
     };
   }
   const globalTeamPath = resolveGlobalTeamMarkdownPath(input.homeDir);
-  if (await pathExists5(globalTeamPath)) {
+  if (await pathExists4(globalTeamPath)) {
     return {
       source: "global",
       teamPath: globalTeamPath,
@@ -8830,12 +8457,12 @@ function resolveTeamAgentReference(input) {
   if (reference.includes(":")) {
     throw new Error(`Unsupported team agent reference for ${input.roleId}: ${reference}`);
   }
-  if (isAbsolute5(reference)) {
+  if (isAbsolute6(reference)) {
     throw new Error(`Team agent path for ${input.roleId} must be repo-relative.`);
   }
-  const sourcePath = resolve4(input.repoRoot, reference);
+  const sourcePath = resolve3(input.repoRoot, reference);
   const relativePath = relative6(input.repoRoot, sourcePath);
-  if (relativePath === "" || relativePath.startsWith("..") || isAbsolute5(relativePath) || extname(sourcePath) !== ".md") {
+  if (relativePath === "" || relativePath.startsWith("..") || isAbsolute6(relativePath) || extname(sourcePath) !== ".md") {
     throw new Error(`Team agent path for ${input.roleId} must be a repo-local Markdown file.`);
   }
   return {
@@ -8860,7 +8487,7 @@ async function readTeamAgentDefinition(input) {
   const reference = resolveTeamAgentReference(input);
   const markdown = await readTeamAgentMarkdown(reference);
   const parsed = parseMarkdownWithFrontmatter(markdown);
-  const evodev = isRecord8(parsed.frontmatter.evodev) ? parsed.frontmatter.evodev : {};
+  const evodev = isRecord7(parsed.frontmatter.evodev) ? parsed.frontmatter.evodev : {};
   return {
     roleId: input.roleId,
     name: optionalString5(parsed.frontmatter.name) ?? defaultRoleName(input.roleId),
@@ -8977,7 +8604,7 @@ async function resolveTeamRole(input) {
   };
 }
 function parseTeamRoleDefinition(value, defaults) {
-  const input = isRecord8(value) ? value : {};
+  const input = isRecord7(value) ? value : {};
   const roleId = optionalString5(input.roleId) ?? defaults.roleId;
   assertSafeId(roleId, "roleId");
   const runtime = parseRuntime(input.runtime, defaults.defaultRuntime);
@@ -9201,7 +8828,7 @@ class TmuxRuntimeAdapter {
 
 class NodeTeamRuntimeCommandRunner {
   async run(command, args, options = {}) {
-    return new Promise((resolve5, reject) => {
+    return new Promise((resolve4, reject) => {
       const child = spawn(command, args, { stdio: ["pipe", "pipe", "pipe"] });
       let stdout = "";
       let stderr = "";
@@ -9215,7 +8842,7 @@ class NodeTeamRuntimeCommandRunner {
       });
       child.once("error", reject);
       child.once("close", (code) => {
-        resolve5({ exitCode: code ?? 1, stdout, stderr });
+        resolve4({ exitCode: code ?? 1, stdout, stderr });
       });
       child.stdin.end(options.input ?? "");
     });
@@ -9506,7 +9133,7 @@ async function listDefaultTeamOverlayAssets(assetsRootDir) {
   await assertReadableFile(teamPath, "Default team asset");
   let entries;
   try {
-    entries = await readdir8(agentsDir, { withFileTypes: true });
+    entries = await readdir9(agentsDir, { withFileTypes: true });
   } catch (error) {
     throw new Error(`Cannot read default team agents directory ${agentsDir}: ${describeError2(error)}`);
   }
@@ -9541,8 +9168,8 @@ async function writeTextFileIfMissing(path, content) {
       throw new Error(`Cannot inspect ${path}: ${describeError2(error)}`);
     }
   }
-  await mkdir8(dirname8(path), { recursive: true });
-  await writeFile7(path, content.endsWith(`
+  await mkdir7(dirname8(path), { recursive: true });
+  await writeFile6(path, content.endsWith(`
 `) ? content : `${content}
 `, "utf8");
   return true;
@@ -9550,7 +9177,7 @@ async function writeTextFileIfMissing(path, content) {
 function parseTeamDefinitionAgents(value) {
   if (value === undefined)
     return {};
-  if (!isRecord8(value))
+  if (!isRecord7(value))
     throw new Error("team.md agents must be a role-id map.");
   const agents = {};
   for (const [roleId, reference] of Object.entries(value)) {
@@ -9616,7 +9243,7 @@ function parseSimpleYaml(content) {
       throw new Error(`Invalid YAML line: ${trimmed}`);
     const key = trimmed.slice(0, separator).trim();
     const rawValue = trimmed.slice(separator + 1).trim();
-    if (!isRecord8(parent))
+    if (!isRecord7(parent))
       throw new Error(`Invalid YAML parent for key ${key}.`);
     if (rawValue === "") {
       const next = findNextYamlContentLine(lines, index + 1);
@@ -9681,7 +9308,7 @@ function resolveGlobalTeamMarkdownPath(homeDir) {
   return join13(resolveEvoDevPaths(homeDir).rootDir, "team", "team.md");
 }
 function parseRolePermissions(value, main) {
-  const input = isRecord8(value) ? value : {};
+  const input = isRecord7(value) ? value : {};
   return {
     writeMode: parseWriteMode(input.writeMode, "repo-write"),
     canUseTeamsMcp: optionalBoolean2(input.canUseTeamsMcp) ?? true,
@@ -9690,14 +9317,14 @@ function parseRolePermissions(value, main) {
   };
 }
 function parseRolePolicy(value, recordTranscript) {
-  const input = isRecord8(value) ? value : {};
+  const input = isRecord7(value) ? value : {};
   return {
     roleInstancePolicy: "single-per-role",
     recordTranscript: optionalBoolean2(input.recordTranscript) ?? recordTranscript
   };
 }
 function parseTeamRunRecord(value) {
-  if (!isRecord8(value) || value.version !== 1)
+  if (!isRecord7(value) || value.version !== 1)
     throw new Error("Invalid team run record.");
   const run = value;
   assertSafeId(run.runId, "runId");
@@ -9707,7 +9334,7 @@ function parseTeamRunRecord(value) {
   return run;
 }
 function parseTeamAgentRecord(value) {
-  if (!isRecord8(value) || value.version !== 1)
+  if (!isRecord7(value) || value.version !== 1)
     throw new Error("Invalid team agent record.");
   const agent = value;
   assertSafeId(agent.agentId, "agentId");
@@ -9728,7 +9355,7 @@ function parseTeamAgentRecord(value) {
   ].includes(agent.status)) {
     throw new Error("Invalid agent status.");
   }
-  const nativeSessionValue = isRecord8(value.nativeSession) ? value.nativeSession : {};
+  const nativeSessionValue = isRecord7(value.nativeSession) ? value.nativeSession : {};
   return {
     ...agent,
     nativeSession: {
@@ -9738,7 +9365,7 @@ function parseTeamAgentRecord(value) {
   };
 }
 function parseTeamMessageRecord(value) {
-  if (!isRecord8(value) || value.version !== 1)
+  if (!isRecord7(value) || value.version !== 1)
     throw new Error("Invalid team message record.");
   const message = value;
   assertSafeId(message.messageId, "messageId");
@@ -9767,7 +9394,7 @@ function parseTeamPendingMessageRecord(value) {
   };
 }
 function parseTeamMessageListFile(value) {
-  if (!isRecord8(value) || value.version !== 1)
+  if (!isRecord7(value) || value.version !== 1)
     throw new Error("Invalid team message list.");
   const messages = Array.isArray(value.messages) ? value.messages.map(parseTeamPendingMessageRecord) : [];
   return {
@@ -9777,7 +9404,7 @@ function parseTeamMessageListFile(value) {
   };
 }
 function parseTeamEventRecord(value) {
-  if (!isRecord8(value) || value.version !== 1)
+  if (!isRecord7(value) || value.version !== 1)
     throw new Error("Invalid team event record.");
   const event = value;
   assertSafeId(event.eventId, "eventId");
@@ -9949,7 +9576,7 @@ async function readTeamBindingConfig(path) {
   }
 }
 function parseTeamBindingConfig(value) {
-  if (!isRecord8(value) || value.version !== 1)
+  if (!isRecord7(value) || value.version !== 1)
     throw new Error("Invalid team binding config.");
   const updatedAt = optionalString5(value.updatedAt) ?? "unknown";
   const rolesValue = Array.isArray(value.roles) ? value.roles : [];
@@ -9960,7 +9587,7 @@ function parseTeamBindingConfig(value) {
   };
 }
 function parseTeamBindingRecord(value) {
-  if (!isRecord8(value) || value.version !== 1) {
+  if (!isRecord7(value) || value.version !== 1) {
     throw new Error("Invalid team binding record.");
   }
   const roleId = optionalString5(value.roleId);
@@ -9994,7 +9621,7 @@ function mergeTeamRoleBindings(global, project) {
 function isNotFoundError3(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
-async function pathExists5(path) {
+async function pathExists4(path) {
   try {
     await stat6(path);
     return true;
@@ -10005,20 +9632,20 @@ async function pathExists5(path) {
   }
 }
 async function writeJson3(path, value) {
-  await mkdir8(dirname8(path), { recursive: true });
-  await writeFile7(path, `${JSON.stringify(value, null, 2)}
+  await mkdir7(dirname8(path), { recursive: true });
+  await writeFile6(path, `${JSON.stringify(value, null, 2)}
 `, "utf8");
 }
 async function appendJsonLine2(path, value) {
-  await mkdir8(dirname8(path), { recursive: true });
+  await mkdir7(dirname8(path), { recursive: true });
   await appendFile3(path, `${JSON.stringify(value)}
 `, "utf8");
 }
-async function readJsonLines(path, parse) {
+async function readJsonLines(path, parse2) {
   try {
     const text2 = await readFile10(path, "utf8");
     return text2.split(`
-`).filter((line) => line.trim() !== "").map((line) => parse(JSON.parse(line)));
+`).filter((line) => line.trim() !== "").map((line) => parse2(JSON.parse(line)));
   } catch (error) {
     if (isNotFoundError3(error))
       return [];
@@ -10048,7 +9675,7 @@ function optionalNullableString(value) {
 function optionalBoolean2(value) {
   return typeof value === "boolean" ? value : undefined;
 }
-function isRecord8(value) {
+function isRecord7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function describeError2(error) {
@@ -10108,7 +9735,7 @@ var DEFAULT_EVENT_SETTINGS = {
   WorktreeCreate: true,
   WorktreeRemove: true
 };
-var SENSITIVE_TEXT_PATTERN4 = /https?:\/\/\S+|\b(secret|token|password|passwd|private|internal|api[_-]?key|apikey|credential|credentials|\.env)\b/i;
+var SENSITIVE_TEXT_PATTERN3 = /https?:\/\/\S+|\b(secret|token|password|passwd|private|internal|api[_-]?key|apikey|credential|credentials|\.env)\b/i;
 var SOURCE_LIKE_PATTERN = /\b(function|class|import|export|const|let|var)\b.*[{};]/s;
 var TEAM_MESSAGE_DELIVERY_EVENTS = new Set([
   "SessionStart",
@@ -10124,6 +9751,12 @@ var CODEX_STOP_EVENTS_WITHOUT_ADDITIONAL_CONTEXT = new Set([
   "Stop",
   "SubagentStop"
 ]);
+var COMPLETION_EVENTS_WITHOUT_DEVELOPMENT_DIAGNOSTICS = new Set([
+  "Stop",
+  "SubagentStop",
+  "TaskCompleted",
+  "TeammateIdle"
+]);
 function createDefaultHookSettings() {
   return {
     enabled: true,
@@ -10152,9 +9785,9 @@ function parseHookSettings(value) {
   const defaults = createDefaultHookSettings();
   if (value === undefined || value === null)
     return defaults;
-  if (!isRecord9(value))
+  if (!isRecord8(value))
     throw new Error("Invalid hooks settings; expected object.");
-  const observability = isRecord9(value.observability) ? value.observability : undefined;
+  const observability = isRecord8(value.observability) ? value.observability : undefined;
   optionalBoolean3(observability?.metadataOnly, defaults.observability.metadataOnly, "hooks.observability.metadataOnly");
   optionalBoolean3(observability?.rawPayloadStorage, defaults.observability.rawPayloadStorage, "hooks.observability.rawPayloadStorage");
   return {
@@ -10288,8 +9921,7 @@ function resolveHookRuntimeSessionPaths(input) {
   const sessionDir = join14(input.homeDir, ".evodev", "STATE", "hooks", "sessions", input.sessionKey);
   return {
     sessionDir,
-    bindingPath: join14(sessionDir, "binding.json"),
-    contractPath: join14(sessionDir, "contract.json")
+    bindingPath: join14(sessionDir, "binding.json")
   };
 }
 async function handleHookRuntime(input) {
@@ -10305,7 +9937,13 @@ async function handleHookRuntime(input) {
       summary: `Hook ${input.event.type} ignored because EvoDev hooks are disabled.`
     };
   }
+  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;
   if (input.event.type === "SessionStart")
     result = await handleSessionStart(input);
@@ -10333,7 +9971,8 @@ async function handleHookRuntime(input) {
   const messageDiagnostics = await deliverPendingTeamMessagesFromHook(input, result);
   const scopedContextDiagnostics = await injectScopedKnowledgeContextFromHook(input, result);
   const teamStateDiagnostics = await recordTeamAgentHookStateFromHook(input);
-  return appendRuntimeDiagnostics(appendRuntimeDiagnostics(appendRuntimeDiagnostics(appendRuntimeDiagnostics(appendRuntimeDiagnostics(appendRuntimeDiagnostics(result, diagnostics), sessionMemoryDiagnostics), evolutionDiagnostics), messageDiagnostics), scopedContextDiagnostics), teamStateDiagnostics);
+  const completed = appendRuntimeDiagnostics(appendRuntimeDiagnostics(appendRuntimeDiagnostics(appendRuntimeDiagnostics(appendRuntimeDiagnostics(appendRuntimeDiagnostics(appendRuntimeDiagnostics(result, diagnostics), projectDiagnostics), sessionMemoryDiagnostics), evolutionDiagnostics), messageDiagnostics), scopedContextDiagnostics), teamStateDiagnostics);
+  return appendDevelopmentHookDiagnostics(input, completed);
 }
 function formatHookRuntimeOutput(result) {
   return result.output === null ? "" : `${JSON.stringify(result.output)}
@@ -10342,6 +9981,29 @@ function formatHookRuntimeOutput(result) {
 function isHookEventEnabled(settings, target, eventType) {
   return settings.enabled === true && settings.targets[target]?.enabled === true && settings.targets[target]?.events[eventType] === true;
 }
+async function recordDiscoveredProjectFromHook(input) {
+  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) {
   const environment = input.environment ?? {};
   const runId = optionalPayloadString(environment.EVODEV_TEAM_RUN_ID);
@@ -10580,41 +10242,27 @@ async function handleSessionStart(input) {
   });
 }
 async function handleUserPromptSubmit(input) {
-  const classification = classifyUserPrompt(input.rawPayload.prompt ?? input.rawPayload.userPrompt);
   const sessionKey = resolveHookSessionKey(input.rawPayload);
   const paths2 = 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() : previousBinding?.teamRuntimeContextDeliveredAt ?? null;
   const binding = {
     version: 1,
     target: input.target,
     sessionKey,
-    taskId: contract.taskId,
-    contractPath: paths2.contractPath,
     cwd: optionalPayloadString(input.rawPayload.cwd),
-    route: contract.route,
     teamRuntimeContextDeliveredAt,
     updatedAt: input.receivedAt ?? new Date().toISOString()
   };
-  await writeTaskContract(paths2.contractPath, contract, { overwrite: true });
   await writeJsonFile2(paths2.bindingPath, binding);
-  const visibleContext = createUserPromptVisibleContext({
-    classification,
-    contract,
-    contractPath: paths2.contractPath
-  });
-  let output = visibleContext === null || !shouldShowDiagnostics ? null : hookOutput(input.event.type, {
-    additionalContext: visibleContext
-  });
+  let output = null;
   if (teamRuntimeContext !== null) {
     output = appendAdditionalContext(output, input.event.type, teamRuntimeContext);
   }
   return createRuntimeResult(input, output, {
-    summary: "User prompt observed; Task Contract prepared.",
-    stateWrites: [paths2.contractPath, paths2.bindingPath]
+    summary: "User prompt observed; session binding updated.",
+    stateWrites: [paths2.bindingPath]
   });
 }
 async function createTeamRuntimeContextForUserPrompt(input) {
@@ -10642,40 +10290,11 @@ async function handlePreToolUse(input) {
   });
 }
 async function handlePostToolUse(input) {
-  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 = {
-    ...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) {
-  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.`
   });
 }
 async function handlePreCompact(input) {
@@ -10726,7 +10345,7 @@ function hookOutput(eventName, output) {
 function appendAdditionalContext(output, eventName, context) {
   if (output === null)
     return hookOutput(eventName, { additionalContext: context });
-  const hookSpecificOutput = isRecord9(output.hookSpecificOutput) ? output.hookSpecificOutput : {};
+  const hookSpecificOutput = isRecord8(output.hookSpecificOutput) ? output.hookSpecificOutput : {};
   const previous = typeof hookSpecificOutput.additionalContext === "string" ? hookSpecificOutput.additionalContext : "";
   return {
     ...output,
@@ -10739,6 +10358,34 @@ ${context}`
     }
   };
 }
+function appendDevelopmentHookDiagnostics(input, result) {
+  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) {
+  return input.target === "claude" && (input.event.type === "Stop" || input.event.type === "SubagentStop") && input.rawPayload.stop_hook_active === true;
+}
+function formatDevelopmentHookDiagnostics(input) {
+  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(`
+`);
+}
 function formatTeamInboxContext(messages) {
   const blocks = messages.map((message) => [
     "[EvoDev team message]",
@@ -10762,101 +10409,6 @@ function truncateTeamMessageBody(value) {
     return value;
   return `${value.slice(0, 4000)}...[truncated:${value.length - 4000}]`;
 }
-function createUserPromptVisibleContext(input) {
-  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, classification) {
-  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) {
-  return target === "codex" ? "Codex" : "Claude";
-}
-function classifyUserPrompt(value) {
-  const text2 = typeof value === "string" ? value.toLowerCase() : "";
-  const riskTerms = [
-    "security",
-    "release",
-    "publish",
-    "hook",
-    "memory",
-    "learning",
-    "secret",
-    "privacy"
-  ].filter((term) => text2.includes(term));
-  let kind = "feature";
-  if (/\bbug|fix|error|failed|failure\b/.test(text2))
-    kind = "bugfix";
-  if (/\brefactor|migration|migrate\b/.test(text2))
-    kind = "refactor";
-  if (/\breview|audit\b/.test(text2))
-    kind = "review";
-  if (/\btest|coverage\b/.test(text2))
-    kind = "test";
-  if (/\bdoc|readme|guide\b/.test(text2))
-    kind = "docs";
-  if (riskTerms.includes("security") || riskTerms.includes("privacy"))
-    kind = "security";
-  if (riskTerms.includes("release") || riskTerms.includes("publish"))
-    kind = "release";
-  return {
-    kind,
-    riskTerms,
-    needsClarification: text2.trim().length < 12 || /\bmaybe|unclear|not sure\b/.test(text2)
-  };
-}
-async function readActiveContract(homeDir, payload) {
-  const binding = await readSessionBinding(homeDir, payload);
-  if (binding?.contractPath === null || binding?.contractPath === undefined)
-    return null;
-  try {
-    return JSON.parse(await readFile11(binding.contractPath, "utf8"));
-  } catch (error) {
-    if (isNotFoundError4(error))
-      return null;
-    throw error;
-  }
-}
 async function readSessionBinding(homeDir, payload) {
   const sessionKey = resolveHookSessionKey(payload);
   const paths2 = resolveHookRuntimeSessionPaths({ homeDir, sessionKey });
@@ -10875,8 +10427,8 @@ function resolveHookSessionKey(payload) {
   return `session-${sha256Short(source)}`;
 }
 async function writeJsonFile2(path, value) {
-  await mkdir9(dirname9(path), { recursive: true });
-  await writeFile8(path, `${JSON.stringify(value, null, 2)}
+  await mkdir8(dirname9(path), { recursive: true });
+  await writeFile7(path, `${JSON.stringify(value, null, 2)}
 `, "utf8");
 }
 function optionalPayloadString(value) {
@@ -10885,9 +10437,6 @@ function optionalPayloadString(value) {
 function safeDiagnosticId(value) {
   return value.replace(/[^A-Za-z0-9._-]/g, "-").slice(0, 120) || "unknown";
 }
-function optionalPayloadNumber(value) {
-  return typeof value === "number" && Number.isFinite(value) ? value : null;
-}
 function isNotFoundError4(error) {
   return error instanceof Error && "code" in error && error.code === "ENOENT";
 }
@@ -10901,9 +10450,9 @@ function normalizeHookEventType(type, warnings) {
   throw new Error(`Unsupported hook event type: ${type}`);
 }
 function parseHookTargetSettings(value, defaults, target) {
-  const targets = isRecord9(value) ? value : {};
-  const targetSettings = isRecord9(targets[target]) ? targets[target] : {};
-  const events = isRecord9(targetSettings.events) ? targetSettings.events : {};
+  const targets = isRecord8(value) ? value : {};
+  const targetSettings = isRecord8(targets[target]) ? targets[target] : {};
+  const events = isRecord8(targetSettings.events) ? targetSettings.events : {};
   const parsedEvents = { ...defaults.events };
   for (const eventType of CANONICAL_HOOK_EVENT_TYPES) {
     parsedEvents[eventType] = optionalBoolean3(events[eventType], defaults.events[eventType], `hooks.targets.${target}.events.${eventType}`);
@@ -10915,7 +10464,7 @@ function parseHookTargetSettings(value, defaults, target) {
 }
 function extractMetadata(type, payload, redactions) {
   const metadata = {};
-  const toolInput = isRecord9(payload.tool_input) ? payload.tool_input : isRecord9(payload.toolInput) ? payload.toolInput : {};
+  const toolInput = isRecord8(payload.tool_input) ? payload.tool_input : isRecord8(payload.toolInput) ? payload.toolInput : {};
   const toolName = optionalSanitizedString(payload.tool_name ?? payload.toolName, redactions);
   if (toolName !== null)
     metadata.toolName = toolName;
@@ -10962,7 +10511,7 @@ function summarizeEvent(type, metadata) {
 function optionalSanitizedString(value, redactions, options = {}) {
   if (typeof value !== "string" || value.length === 0)
     return null;
-  if (SENSITIVE_TEXT_PATTERN4.test(value) || SOURCE_LIKE_PATTERN.test(value)) {
+  if (SENSITIVE_TEXT_PATTERN3.test(value) || SOURCE_LIKE_PATTERN.test(value)) {
     redactions.push(options.classifyOnly ? "sensitive-command" : "sensitive-text");
     return options.classifyOnly ? value : "[redacted]";
   }
@@ -10993,7 +10542,7 @@ function optionalNumber(value) {
 function formatMetadataValue(value) {
   return Array.isArray(value) ? value.join(",") : String(value);
 }
-function isRecord9(value) {
+function isRecord8(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -11295,20 +10844,20 @@ function expectNonNegativeInteger(value, path) {
   return value;
 }
 // packages/core/src/config/store.ts
-import { mkdir as mkdir10, readFile as readFile13, writeFile as writeFile9 } from "node:fs/promises";
+import { mkdir as mkdir9, readFile as readFile13, writeFile as writeFile8 } from "node:fs/promises";
 import { dirname as dirname10 } from "node:path";
 function createCoreConfigStore(homeDir) {
   const paths2 = resolveEvoDevPaths(homeDir);
   return {
     paths: paths2,
     async ensureBaseDirs() {
-      await mkdir10(paths2.stateDir, { recursive: true });
-      await mkdir10(paths2.logsDir, { recursive: true });
-      await mkdir10(paths2.knowledgeDir, { recursive: true });
-      await mkdir10(paths2.evosCasesDir, { recursive: true });
-      await mkdir10(paths2.roleAgentsDir, { recursive: true });
-      await mkdir10(paths2.teamsDir, { recursive: true });
-      await mkdir10(paths2.runsDir, { recursive: true });
+      await mkdir9(paths2.stateDir, { recursive: true });
+      await mkdir9(paths2.logsDir, { recursive: true });
+      await mkdir9(paths2.knowledgeDir, { recursive: true });
+      await mkdir9(paths2.evosCasesDir, { recursive: true });
+      await mkdir9(paths2.roleAgentsDir, { recursive: true });
+      await mkdir9(paths2.teamsDir, { recursive: true });
+      await mkdir9(paths2.runsDir, { recursive: true });
     },
     async ensureKnowledgeBase() {
       await ensureKnowledgeBaseFiles(paths2);
@@ -11356,8 +10905,8 @@ async function initializeCoreConfig(homeDir) {
   return store;
 }
 async function ensureKnowledgeBaseFiles(paths2) {
-  await mkdir10(paths2.knowledgeDir, { recursive: true });
-  await mkdir10(paths2.evosCasesDir, { recursive: true });
+  await mkdir9(paths2.knowledgeDir, { recursive: true });
+  await mkdir9(paths2.evosCasesDir, { recursive: true });
   await ensureOkfKnowledgeBase(paths2.homeDir);
   await writeTextIfMissing2(`${paths2.knowledgeDir}/README.md`, [
     "# EvoDev Knowledge",
@@ -11426,7 +10975,7 @@ async function ensureKnowledgeBaseFiles(paths2) {
     teams: []
   });
 }
-async function readJsonFile2(filePath, parse) {
+async function readJsonFile2(filePath, parse2) {
   let raw;
   try {
     raw = await readFile13(filePath, "utf8");
@@ -11440,7 +10989,7 @@ async function readJsonFile2(filePath, parse) {
     throw new EvoDevConfigError(`Invalid JSON (${describeFileError2(error)})`, filePath);
   }
   try {
-    return parse(json);
+    return parse2(json);
   } catch (error) {
     if (error instanceof EvoDevConfigError) {
       throw new EvoDevConfigError(error.message, filePath);
@@ -11448,9 +10997,9 @@ async function readJsonFile2(filePath, parse) {
     throw error;
   }
 }
-async function readJsonFileOrDefault(filePath, parse, fallback) {
+async function readJsonFileOrDefault(filePath, parse2, fallback) {
   try {
-    return await readJsonFile2(filePath, parse);
+    return await readJsonFile2(filePath, parse2);
   } catch (error) {
     if (error instanceof EvoDevConfigError && error.message.includes("ENOENT")) {
       return fallback;
@@ -11486,7 +11035,7 @@ async function writeIndexIfMissingOrMigrate(filePath, kind, defaults) {
   } catch (error) {
     throw new EvoDevConfigError(`Invalid bootstrap index JSON (${describeFileError2(error)})`, filePath);
   }
-  if (!isRecord10(existing) || existing.kind !== kind)
+  if (!isRecord9(existing) || existing.kind !== kind)
     return;
   const migrated = { ...defaults, ...existing };
   if (Object.keys(defaults).every((key) => (key in existing)))
@@ -11498,16 +11047,16 @@ async function writeTextIfMissing2(filePath, value) {
     await readFile13(filePath, "utf8");
   } catch (error) {
     if (isNodeError2(error) && error.code === "ENOENT") {
-      await mkdir10(dirname10(filePath), { recursive: true });
-      await writeFile9(filePath, value, "utf8");
+      await mkdir9(dirname10(filePath), { recursive: true });
+      await writeFile8(filePath, value, "utf8");
       return;
     }
     throw new EvoDevConfigError(`Cannot inspect config file (${describeFileError2(error)})`, filePath);
   }
 }
 async function writeJsonFile3(filePath, value) {
-  await mkdir10(dirname10(filePath), { recursive: true });
-  await writeFile9(filePath, `${JSON.stringify(value, null, 2)}
+  await mkdir9(dirname10(filePath), { recursive: true });
+  await writeFile8(filePath, `${JSON.stringify(value, null, 2)}
 `, "utf8");
 }
 function describeFileError2(error) {
@@ -11519,12 +11068,12 @@ function describeFileError2(error) {
 function isNodeError2(error) {
   return error instanceof Error && "code" in error;
 }
-function isRecord10(value) {
+function isRecord9(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 // packages/core/src/daemon/index.ts
 import { randomBytes } from "node:crypto";
-import { mkdir as mkdir13, readFile as readFile16, readdir as readdir11, rm as rm4, stat as stat9, writeFile as writeFile12 } from "node:fs/promises";
+import { mkdir as mkdir12, readFile as readFile16, readdir as readdir12, rm as rm4, stat as stat9, writeFile as writeFile11 } from "node:fs/promises";
 import { createServer } from "node:http";
 import { dirname as dirname13, join as join19 } from "node:path";
 
@@ -11676,7 +11225,7 @@ __export(exports_processor, {
 });
 
 // packages/core/src/evolution/evidence/analysis.ts
-import { readFile as readFile14, readdir as readdir9 } from "node:fs/promises";
+import { readFile as readFile14, readdir as readdir10 } from "node:fs/promises";
 import { basename as basename3, join as join15 } from "node:path";
 async function analyzeEvolutionRun(input) {
   const projectKey = resolveEvolutionProjectKey(input);
@@ -11689,8 +11238,8 @@ async function analyzeEvolutionRun(input) {
   const logsDir = resolveEvoDevPaths(input.homeDir).logsDir;
   const projectRunAgentsDir = join15(logsDir, "teams", projectKey, runId, "agents");
   const legacyProjectRunAgentsDir = join15(logsDir, projectKey, runId, "agents");
-  const agentDirs = await pathExists(projectRunAgentsDir) ? await readdir9(projectRunAgentsDir, { withFileTypes: true }) : [];
-  const legacyAgentDirs = await pathExists(legacyProjectRunAgentsDir) ? await readdir9(legacyProjectRunAgentsDir, { withFileTypes: true }) : [];
+  const agentDirs = await pathExists(projectRunAgentsDir) ? await readdir10(projectRunAgentsDir, { withFileTypes: true }) : [];
+  const legacyAgentDirs = await pathExists(legacyProjectRunAgentsDir) ? await readdir10(legacyProjectRunAgentsDir, { withFileTypes: true }) : [];
   if (agentDirs.length === 0 && legacyAgentDirs.length === 0) {
     warnings.push(`No agent execution event directory found: ${displayPath(input.homeDir, projectRunAgentsDir)}`);
   } else {
@@ -12376,7 +11925,7 @@ function createProvenance(evidenceWindow, createdAt, sourceRefs) {
   };
 }
 // packages/core/src/evolution/processor/process.ts
-import { mkdir as mkdir11, rm as rm3, stat as stat7, writeFile as writeFile10 } from "node:fs/promises";
+import { mkdir as mkdir10, rm as rm3, stat as stat7, writeFile as writeFile9 } from "node:fs/promises";
 import { dirname as dirname11, join as join17 } from "node:path";
 var PROCESS_LOCK_STALE_MS2 = 5 * 60 * 1000;
 async function processEvolutionTriggers(input) {
@@ -12537,9 +12086,9 @@ async function processEvolutionTriggers(input) {
 async function acquireEvolutionProcessLock(homeDir, now) {
   const paths2 = resolveEvoDevPaths(homeDir);
   const lockPath = join17(paths2.stateDir, "evolution", ".process.lock");
-  await mkdir11(dirname11(lockPath), { recursive: true });
+  await mkdir10(dirname11(lockPath), { recursive: true });
   try {
-    await writeFile10(lockPath, `${JSON.stringify({
+    await writeFile9(lockPath, `${JSON.stringify({
       schemaVersion: 1,
       kind: "evolution-process-lock",
       createdAt: now,
@@ -12562,7 +12111,7 @@ async function releaseEvolutionProcessLock(lock) {
   await rm3(lock.path, { force: true });
 }
 // packages/core/src/observability/index.ts
-import { mkdir as mkdir12, readFile as readFile15, readdir as readdir10, stat as stat8, writeFile as writeFile11 } from "node:fs/promises";
+import { mkdir as mkdir11, readFile as readFile15, readdir as readdir11, stat as stat8, writeFile as writeFile10 } from "node:fs/promises";
 import { dirname as dirname12, join as join18 } from "node:path";
 var EVENT_TYPE_TO_DIR = {
   "verification.completed": "verification",
@@ -12570,7 +12119,7 @@ var EVENT_TYPE_TO_DIR = {
   "test-run.completed": "tests",
   "review.finding": "reviews"
 };
-var FORBIDDEN_RAW_KEYS3 = new Set([
+var FORBIDDEN_RAW_KEYS2 = new Set([
   "commandoutput",
   "memorybodies",
   "memorybody",
@@ -12592,11 +12141,11 @@ var FORBIDDEN_RAW_KEYS3 = new Set([
   "transcriptbody",
   "transcripttext"
 ]);
-var SENSITIVE_TEXT_PATTERN5 = /https?:\/\/\S+|\b(secret|token|password|passwd|private|internal|api[_-]?key|apikey|credential|credentials|raw log|raw source|raw prompt)\b/i;
+var SENSITIVE_TEXT_PATTERN4 = /https?:\/\/\S+|\b(secret|token|password|passwd|private|internal|api[_-]?key|apikey|credential|credentials|raw log|raw source|raw prompt)\b/i;
 function createObservabilityEvent(input) {
   const event = {
     version: 1,
-    eventId: sanitizeId3(input.eventId),
+    eventId: sanitizeId2(input.eventId),
     type: input.type,
     timestamp: input.timestamp ?? new Date().toISOString(),
     scope: input.scope,
@@ -12608,7 +12157,7 @@ function createObservabilityEvent(input) {
       sourceContentStored: false,
       promptStored: false
     },
-    summary: sanitizeText3(input.summary),
+    summary: sanitizeText2(input.summary),
     data: sanitizeData(input.data ?? {})
   };
   validateObservabilityEvent(event);
@@ -12631,8 +12180,8 @@ function resolveObservabilityStorePaths(homeDir, type) {
 async function appendObservabilityEvent(homeDir, event) {
   validateObservabilityEvent(event);
   const paths2 = resolveObservabilityStorePaths(homeDir, event.type);
-  await mkdir12(dirname12(paths2.eventsPath), { recursive: true });
-  await writeFile11(paths2.eventsPath, `${JSON.stringify(event)}
+  await mkdir11(dirname12(paths2.eventsPath), { recursive: true });
+  await writeFile10(paths2.eventsPath, `${JSON.stringify(event)}
 `, { encoding: "utf8", flag: "a" });
   return paths2.eventsPath;
 }
@@ -12641,7 +12190,7 @@ async function listObservabilityEvents(homeDir, type) {
   const events = [];
   for (const eventType of eventTypes) {
     const path = resolveObservabilityStorePaths(homeDir, eventType).eventsPath;
-    if (!await pathExists6(path))
+    if (!await pathExists5(path))
       continue;
     const lines = (await readFile15(path, "utf8")).split(`
 `).filter(Boolean);
@@ -12656,7 +12205,7 @@ async function listObservabilityEvents(homeDir, type) {
 async function dryRunObservabilityRetentionCleanup(homeDir) {
   const root = join18(homeDir, ".evodev", "OBSERVABILITY");
   const candidates = [];
-  if (!await pathExists6(root))
+  if (!await pathExists5(root))
     return { candidates, totalBytes: 0 };
   for (const file of await collectJsonlFiles(root)) {
     const fileStat = await stat8(file);
@@ -12689,13 +12238,13 @@ function sanitizeData(data) {
   const sanitized = {};
   for (const [key, value] of Object.entries(data)) {
     const normalizedKey = normalizeKey(key);
-    if (FORBIDDEN_RAW_KEYS3.has(normalizedKey)) {
+    if (FORBIDDEN_RAW_KEYS2.has(normalizedKey)) {
       throw new Error(`Observability data contains forbidden raw field: ${key}`);
     }
     if (typeof value === "string")
-      sanitized[key] = sanitizeText3(value);
+      sanitized[key] = sanitizeText2(value);
     else if (Array.isArray(value))
-      sanitized[key] = value.map(sanitizeText3);
+      sanitized[key] = value.map(sanitizeText2);
     else
       sanitized[key] = value;
   }
@@ -12705,7 +12254,7 @@ function assertNoForbiddenContent(value) {
   if (typeof value === "string") {
     if (value === "local-private")
       return;
-    if (SENSITIVE_TEXT_PATTERN5.test(value))
+    if (SENSITIVE_TEXT_PATTERN4.test(value))
       throw new Error("Observability event contains sensitive content.");
     return;
   }
@@ -12718,14 +12267,14 @@ function assertNoForbiddenContent(value) {
     return;
   for (const [key, child] of Object.entries(value)) {
     const normalizedKey = normalizeKey(key);
-    if (FORBIDDEN_RAW_KEYS3.has(normalizedKey)) {
+    if (FORBIDDEN_RAW_KEYS2.has(normalizedKey)) {
       throw new Error(`Observability event contains forbidden raw field: ${key}`);
     }
     assertNoForbiddenContent(child);
   }
 }
 async function collectJsonlFiles(root) {
-  const entries = await readdir10(root, { withFileTypes: true });
+  const entries = await readdir11(root, { withFileTypes: true });
   const files = [];
   for (const entry of entries) {
     const path = join18(root, entry.name);
@@ -12736,7 +12285,7 @@ async function collectJsonlFiles(root) {
   }
   return files.sort();
 }
-async function pathExists6(path) {
+async function pathExists5(path) {
   try {
     await stat8(path);
     return true;
@@ -12746,10 +12295,10 @@ async function pathExists6(path) {
     throw error;
   }
 }
-function sanitizeText3(value) {
-  return value.replace(SENSITIVE_TEXT_PATTERN5, "[redacted]").slice(0, 500);
+function sanitizeText2(value) {
+  return value.replace(SENSITIVE_TEXT_PATTERN4, "[redacted]").slice(0, 500);
 }
-function sanitizeId3(value) {
+function sanitizeId2(value) {
   return value.replace(/[^a-zA-Z0-9._-]/g, "-").slice(0, 80) || "event";
 }
 function normalizeKey(key) {
@@ -12758,7 +12307,7 @@ function normalizeKey(key) {
 
 // packages/core/src/daemon/index.ts
 var DEFAULT_PORT = 37645;
-var SENSITIVE_TEXT_PATTERN6 = /https?:\/\/\S+|\b(secret|token|password|passwd|private|internal|api[_-]?key|apikey|credential|credentials|raw log|raw output|raw source|raw prompt|transcript|stdout|stderr)\b/i;
+var SENSITIVE_TEXT_PATTERN5 = /https?:\/\/\S+|\b(secret|token|password|passwd|private|internal|api[_-]?key|apikey|credential|credentials|raw log|raw output|raw source|raw prompt|transcript|stdout|stderr)\b/i;
 function resolveDaemonPaths(homeDir) {
   const rootDir = join19(homeDir, ".evodev", "STATE", "daemon");
   return { rootDir, lockPath: join19(rootDir, "lock.json"), tokenPath: join19(rootDir, "token") };
@@ -12801,14 +12350,14 @@ async function writeDaemonState(input) {
     tokenPath: plan.paths.tokenPath,
     versionText: input.versionText ?? "evodev 0.0.1-alpha"
   };
-  await mkdir13(dirname13(plan.paths.lockPath), { recursive: true });
-  await writeFile12(plan.paths.tokenPath, `${token}
+  await mkdir12(dirname13(plan.paths.lockPath), { recursive: true });
+  await writeFile11(plan.paths.tokenPath, `${token}
 `, {
     encoding: "utf8",
     flag: "wx",
     mode: 384
   });
-  await writeFile12(plan.paths.lockPath, `${JSON.stringify(lock, null, 2)}
+  await writeFile11(plan.paths.lockPath, `${JSON.stringify(lock, null, 2)}
 `, {
     encoding: "utf8",
     flag: "wx",
@@ -12818,7 +12367,7 @@ async function writeDaemonState(input) {
 }
 async function readDaemonLock(homeDir) {
   const paths2 = resolveDaemonPaths(homeDir);
-  if (!await pathExists7(paths2.lockPath))
+  if (!await pathExists6(paths2.lockPath))
     return null;
   const lock = JSON.parse(await readFile16(paths2.lockPath, "utf8"));
   if (lock.version !== 1 || lock.component !== "evodev-daemon")
@@ -12827,7 +12376,7 @@ async function readDaemonLock(homeDir) {
 }
 async function readDaemonToken(homeDir) {
   const paths2 = resolveDaemonPaths(homeDir);
-  if (!await pathExists7(paths2.tokenPath))
+  if (!await pathExists6(paths2.tokenPath))
     return null;
   return (await readFile16(paths2.tokenPath, "utf8")).trim();
 }
@@ -12891,8 +12440,6 @@ async function handleDaemonRequest(input) {
   }
   if (input.method !== "GET")
     return notFound(warnings);
-  if (input.path === "/tasks")
-    return ok(await collectTaskSummaries(input.homeDir, warnings), warnings);
   if (input.path === "/observability/events")
     return ok(await collectObservabilitySummaries(input.homeDir, warnings), warnings);
   if (input.path === "/memory/candidates")
@@ -12942,14 +12489,14 @@ async function runDaemonForeground(input) {
       }));
     }
   });
-  await new Promise((resolve5, reject) => {
+  await new Promise((resolve4, reject) => {
     const onError = (error) => {
       server.off("listening", onListening);
       reject(error);
     };
     const onListening = () => {
       server.off("error", onError);
-      resolve5();
+      resolve4();
     };
     server.once("error", onError);
     server.once("listening", onListening);
@@ -12966,11 +12513,11 @@ async function runDaemonForeground(input) {
     processEvolutionTriggers({ homeDir: input.homeDir, limit: 20 }).then(() => clearDaemonEvolutionProcessError(input.homeDir)).catch((error) => recordDaemonEvolutionProcessError(input.homeDir, error));
   }, 5000);
   evolutionInterval.unref();
-  await new Promise((resolve5, reject) => {
+  await new Promise((resolve4, reject) => {
     server.once("close", () => {
       clearInterval(reconcileInterval);
       clearInterval(evolutionInterval);
-      resolve5();
+      resolve4();
     });
     server.once("error", reject);
   });
@@ -13017,30 +12564,6 @@ function isAllowedLocalOrigin(origin) {
     return false;
   }
 }
-async function collectTaskSummaries(homeDir, warnings) {
-  const root = join19(homeDir, ".evodev", "STATE", "tasks");
-  if (!await pathExists7(root)) {
-    warnings.push("Task store not found; returning empty tasks.");
-    return [];
-  }
-  const contracts = await collectNamedFiles(root, "contract.json");
-  const summaries = [];
-  for (const file of contracts) {
-    try {
-      const contract = JSON.parse(await readFile16(file, "utf8"));
-      summaries.push(sanitizeMetadata({
-        taskId: contract.taskId,
-        status: contract.status,
-        mode: contract.route?.mode ?? null,
-        workflowId: contract.route?.workflowId ?? null,
-        verificationStatus: contract.verification?.status ?? null
-      }));
-    } catch {
-      warnings.push(`Skipped unreadable task contract: ${file}`);
-    }
-  }
-  return summaries;
-}
 async function collectObservabilitySummaries(homeDir, warnings) {
   try {
     return (await listObservabilityEvents(homeDir)).map((event) => sanitizeMetadata({
@@ -13057,7 +12580,7 @@ async function collectObservabilitySummaries(homeDir, warnings) {
 }
 async function collectLearningCandidateSummaries(homeDir, warnings) {
   const path = join19(homeDir, ".evodev", "STATE", "learning", "candidates.jsonl");
-  if (!await pathExists7(path)) {
+  if (!await pathExists6(path)) {
     warnings.push("Learning candidate store not found; returning empty candidates.");
     return [];
   }
@@ -13289,16 +12812,16 @@ async function resumeDashboardTeamRun(homeDir, body, runtimeAdapter) {
   };
 }
 async function collectDirectorySummaries(root, warnings) {
-  if (!await pathExists7(root)) {
+  if (!await pathExists6(root)) {
     warnings.push(`Store not found: ${root}`);
     return [];
   }
-  const entries = await readdir11(root, { withFileTypes: true });
+  const entries = await readdir12(root, { withFileTypes: true });
   return entries.filter((entry) => entry.isDirectory()).map((entry) => ({ id: entry.name, metadataOnly: true }));
 }
 function sanitizeMetadata(value) {
   if (typeof value === "string") {
-    if (SENSITIVE_TEXT_PATTERN6.test(value))
+    if (SENSITIVE_TEXT_PATTERN5.test(value))
       return "[redacted]";
     return value.slice(0, 500);
   }
@@ -13349,8 +12872,8 @@ function resolveDaemonEvolutionProcessErrorPath(homeDir) {
 async function recordDaemonEvolutionProcessError(homeDir, error) {
   try {
     const path = resolveDaemonEvolutionProcessErrorPath(homeDir);
-    await mkdir13(dirname13(path), { recursive: true });
-    await writeFile12(path, `${JSON.stringify({
+    await mkdir12(dirname13(path), { recursive: true });
+    await writeFile11(path, `${JSON.stringify({
       schemaVersion: 1,
       kind: "daemon-evolution-process-error",
       updatedAt: new Date().toISOString(),
@@ -13366,7 +12889,7 @@ async function clearDaemonEvolutionProcessError(homeDir) {
 }
 async function readDaemonEvolutionProcessError(homeDir) {
   const path = resolveDaemonEvolutionProcessErrorPath(homeDir);
-  if (!await pathExists7(path))
+  if (!await pathExists6(path))
     return null;
   const value = JSON.parse(await readFile16(path, "utf8"));
   return typeof value.summary === "string" && value.summary.length > 0 ? value.summary : null;
@@ -13374,25 +12897,13 @@ async function readDaemonEvolutionProcessError(homeDir) {
 function describeError3(error) {
   return error instanceof Error ? error.message : String(error);
 }
-async function collectNamedFiles(root, name) {
-  const entries = await readdir11(root, { withFileTypes: true });
-  const files = [];
-  for (const entry of entries) {
-    const path = join19(root, entry.name);
-    if (entry.isDirectory())
-      files.push(...await collectNamedFiles(path, name));
-    else if (entry.isFile() && entry.name === name)
-      files.push(path);
-  }
-  return files;
-}
 function ok(data, warnings) {
   return { status: 200, body: { ok: true, data: sanitizeMetadata(data), warnings } };
 }
 function notFound(warnings) {
   return { status: 404, body: { ok: false, data: { error: "not found" }, warnings } };
 }
-async function pathExists7(path) {
+async function pathExists6(path) {
   try {
     await stat9(path);
     return true;
@@ -13418,7 +12929,7 @@ __export(exports_review, {
   resolveLearningCandidateQueuePath: () => resolveLearningCandidateQueuePath,
   readLearningReviewDecisions: () => readLearningReviewDecisions,
   readLearningCandidates: () => readLearningCandidates,
-  pathExists: () => pathExists8,
+  pathExists: () => pathExists7,
   parseLearningReviewDecisionRecord: () => parseLearningReviewDecisionRecord,
   parseLearningCandidate: () => parseLearningCandidate,
   listLearningReviewDecisions: () => listLearningReviewDecisions,
@@ -13432,7 +12943,7 @@ __export(exports_review, {
   appendLearningReviewDecision: () => appendLearningReviewDecision,
   appendLearningCandidate: () => appendLearningCandidate
 });
-import { mkdir as mkdir14, readFile as readFile17, stat as stat10, writeFile as writeFile13 } from "node:fs/promises";
+import { mkdir as mkdir13, readFile as readFile17, stat as stat10, writeFile as writeFile12 } from "node:fs/promises";
 import { dirname as dirname14, join as join20 } from "node:path";
 var LEARNING_CANDIDATE_KINDS = [
   "lesson",
@@ -13455,7 +12966,7 @@ var LEARNING_CONFIDENCE_VALUES = ["low", "medium", "high"];
 var LEARNING_DECISION_VALUES = ["rejected", "deferred"];
 var LEARNING_DECIDED_BY_VALUES = ["user"];
 var LEARNING_CANDIDATE_DECISION_STATUSES = ["rejected", "deferred"];
-var FORBIDDEN_RAW_KEYS4 = new Set([
+var FORBIDDEN_RAW_KEYS3 = new Set([
   "commandhistory",
   "commandoutput",
   "credential",
@@ -13490,28 +13001,27 @@ var FORBIDDEN_RAW_KEYS4 = new Set([
   "transcriptbody",
   "transcripttext"
 ]);
-var SENSITIVE_TEXT_PATTERN7 = /https?:\/\/\S+|\b(secret|token|password|passwd|private|internal|api[_-]?key|apikey|credential|credentials|raw log|raw logs|raw output|raw source|raw prompt|shell history|command history)\b/i;
+var SENSITIVE_TEXT_PATTERN6 = /https?:\/\/\S+|\b(secret|token|password|passwd|private|internal|api[_-]?key|apikey|credential|credentials|raw log|raw logs|raw output|raw source|raw prompt|shell history|command history)\b/i;
 var PROTECTED_PATH_PATTERN = /(^|[~/\\])(?:USER|KNOWLEDGE|LEARNING|OBSERVABILITY|PACKS|RELEASES|logs?|memory|\.env[^/\\]*)(?:$|[/\\])|PROJECTS[/\\][^/\\]+[/\\]LEARNING(?:$|[/\\])|\.evodev[/\\](?:USER|KNOWLEDGE|LEARNING|OBSERVABILITY|PACKS|RELEASES)(?:$|[/\\])/i;
 function createLearningCandidate(input) {
   const candidate = {
     version: 1,
-    id: sanitizeId4(input.id),
+    id: sanitizeId3(input.id),
     kind: input.kind,
     status: "candidate",
     routingInfluence: false,
     scope: sanitizeScope(input.scope),
     content: {
-      summary: sanitizeText4(input.content.summary),
-      howToApply: sanitizeText4(input.content.howToApply),
-      antiCriteriaImpact: input.content.antiCriteriaImpact.map(sanitizeText4)
+      summary: sanitizeText3(input.content.summary),
+      howToApply: sanitizeText3(input.content.howToApply),
+      antiCriteriaImpact: input.content.antiCriteriaImpact.map(sanitizeText3)
     },
     provenance: {
       taskId: sanitizeNullableId(input.provenance.taskId),
-      taskContractRef: sanitizeNullableText(input.provenance.taskContractRef),
       workflowRunId: sanitizeNullableId(input.provenance.workflowRunId),
-      evidenceRefs: input.provenance.evidenceRefs.map(sanitizeText4),
+      evidenceRefs: input.provenance.evidenceRefs.map(sanitizeText3),
       sourceType: input.provenance.sourceType,
-      createdAt: sanitizeText4(input.provenance.createdAt),
+      createdAt: sanitizeText3(input.provenance.createdAt),
       createdBy: input.provenance.createdBy,
       rawPromptStored: false,
       sourceContentStored: false,
@@ -13530,7 +13040,7 @@ function createLearningCandidate(input) {
   return candidate;
 }
 function validateLearningCandidate(candidate) {
-  if (!isRecord11(candidate))
+  if (!isRecord10(candidate))
     throw new Error("Learning candidate must be an object.");
   if (candidate.version !== 1)
     throw new Error("Learning candidate version must be 1.");
@@ -13542,33 +13052,33 @@ function validateLearningCandidate(candidate) {
   if (candidate.routingInfluence !== false) {
     throw new Error("Learning candidate routingInfluence must be false in I5.");
   }
-  if (!isRecord11(candidate.scope))
+  if (!isRecord10(candidate.scope))
     throw new Error("Learning candidate scope must be an object.");
   assertEnumValue("scope.level", candidate.scope.level, LEARNING_SCOPE_LEVELS);
-  if (!isRecord11(candidate.content)) {
+  if (!isRecord10(candidate.content)) {
     throw new Error("Learning candidate content must be an object.");
   }
   assertStringField("content.summary", candidate.content.summary);
   assertStringField("content.howToApply", candidate.content.howToApply);
   assertStringArrayField("content.antiCriteriaImpact", candidate.content.antiCriteriaImpact);
-  if (!isRecord11(candidate.provenance)) {
+  if (!isRecord10(candidate.provenance)) {
     throw new Error("Learning candidate provenance must be an object.");
   }
   assertEnumValue("provenance.sourceType", candidate.provenance.sourceType, LEARNING_SOURCE_TYPES);
   assertEnumValue("provenance.createdBy", candidate.provenance.createdBy, LEARNING_CREATED_BY_VALUES);
   assertStringField("provenance.createdAt", candidate.provenance.createdAt);
   assertStringArrayField("provenance.evidenceRefs", candidate.provenance.evidenceRefs);
-  if (!isRecord11(candidate.privacy)) {
+  if (!isRecord10(candidate.privacy)) {
     throw new Error("Learning candidate privacy must be an object.");
   }
   assertEnumValue("privacy.classification", candidate.privacy.classification, ["local-private"]);
-  if (!isRecord11(candidate.review))
+  if (!isRecord10(candidate.review))
     throw new Error("Learning candidate review must be an object.");
   assertEnumValue("review.decision", candidate.review.decision, LEARNING_REVIEW_DECISIONS);
   if (candidate.review.decision !== "pending") {
     throw new Error("Learning candidate review decision must be pending.");
   }
-  if (!isRecord11(candidate.retention)) {
+  if (!isRecord10(candidate.retention)) {
     throw new Error("Learning candidate retention must be an object.");
   }
   assertEnumValue("confidence", candidate.confidence, LEARNING_CONFIDENCE_VALUES);
@@ -13584,7 +13094,7 @@ function validateLearningCandidate(candidate) {
   assertNoForbiddenContent2(candidate);
 }
 function validateLearningReviewDecisionRecord(record) {
-  if (!isRecord11(record))
+  if (!isRecord10(record))
     throw new Error("Learning review decision must be an object.");
   if (record.version !== 1)
     throw new Error("Learning review decision version must be 1.");
@@ -13607,13 +13117,13 @@ function validateLearningReviewDecisionRecord(record) {
   assertNoForbiddenContent2(record);
 }
 function parseLearningCandidate(value) {
-  if (!isRecord11(value))
+  if (!isRecord10(value))
     throw new Error("Invalid learning candidate JSON.");
   validateLearningCandidate(value);
   return value;
 }
 function parseLearningReviewDecisionRecord(value) {
-  if (!isRecord11(value))
+  if (!isRecord10(value))
     throw new Error("Invalid learning review decision JSON.");
   validateLearningReviewDecisionRecord(value);
   return value;
@@ -13633,20 +13143,20 @@ function resolveLearningDecisionPath(homeDir) {
 async function appendLearningCandidate(homeDir, candidate) {
   validateLearningCandidate(candidate);
   const path = resolveLearningCandidateQueuePath(homeDir);
-  await mkdir14(dirname14(path), { recursive: true });
-  await writeFile13(path, `${JSON.stringify(candidate)}
+  await mkdir13(dirname14(path), { recursive: true });
+  await writeFile12(path, `${JSON.stringify(candidate)}
 `, { encoding: "utf8", flag: "a" });
   return path;
 }
 async function listLearningCandidates(homeDir) {
   const path = resolveLearningCandidateQueuePath(homeDir);
-  if (!await pathExists8(path))
+  if (!await pathExists7(path))
     return [];
   return readLearningCandidates(path);
 }
 async function listLearningReviewDecisions(homeDir) {
   const path = resolveLearningDecisionPath(homeDir);
-  if (!await pathExists8(path))
+  if (!await pathExists7(path))
     return [];
   return readLearningReviewDecisions(path);
 }
@@ -13706,7 +13216,7 @@ function lintLearningCandidates(candidates2, options = {}) {
       validateLearningReviewDecisionRecord(decision);
     } catch (error) {
       findings.push({
-        candidateId: isRecord11(decision) && typeof decision.candidateId === "string" ? decision.candidateId : "unknown",
+        candidateId: isRecord10(decision) && typeof decision.candidateId === "string" ? decision.candidateId : "unknown",
         severity: "error",
         field: "decision",
         message: error instanceof Error ? error.message : String(error)
@@ -13778,9 +13288,9 @@ function createLearningReviewDecisionRecord(input) {
   const candidateStatus = input.decision === "rejected" ? "rejected" : "deferred";
   const record = {
     version: 1,
-    candidateId: sanitizeId4(input.candidateId),
+    candidateId: sanitizeId3(input.candidateId),
     decision: input.decision,
-    decidedAt: sanitizeText4(input.decidedAt ?? new Date().toISOString()),
+    decidedAt: sanitizeText3(input.decidedAt ?? new Date().toISOString()),
     decidedBy: "user",
     reason: input.reason === undefined ? null : sanitizeNullableText(input.reason),
     writesAcceptedMemory: false,
@@ -13793,12 +13303,12 @@ function createLearningReviewDecisionRecord(input) {
 async function appendLearningReviewDecision(homeDir, record) {
   validateLearningReviewDecisionRecord(record);
   const path = resolveLearningDecisionPath(homeDir);
-  await mkdir14(dirname14(path), { recursive: true });
-  await writeFile13(path, `${JSON.stringify(record)}
+  await mkdir13(dirname14(path), { recursive: true });
+  await writeFile12(path, `${JSON.stringify(record)}
 `, { encoding: "utf8", flag: "a" });
   return path;
 }
-async function pathExists8(path) {
+async function pathExists7(path) {
   try {
     await stat10(path);
     return true;
@@ -13860,13 +13370,7 @@ async function parseJsonOrJsonlFile(path, parseItem) {
   return values.map(parseItem);
 }
 function candidatePathFields(candidate) {
-  return [
-    ["provenance.taskContractRef", candidate.provenance.taskContractRef],
-    ...candidate.provenance.evidenceRefs.map((ref, index) => [
-      `provenance.evidenceRefs[${index}]`,
-      ref
-    ])
-  ].filter((entry) => typeof entry[1] === "string");
+  return candidate.provenance.evidenceRefs.map((ref, index) => [`provenance.evidenceRefs[${index}]`, ref]).filter((entry) => typeof entry[1] === "string");
 }
 function isCandidateStale(candidate, now) {
   if (candidate.retention.staleAfter === null)
@@ -13894,7 +13398,7 @@ function assertNoForbiddenContent2(value) {
   if (typeof value === "string") {
     if (value === "local-private")
       return;
-    if (SENSITIVE_TEXT_PATTERN7.test(value)) {
+    if (SENSITIVE_TEXT_PATTERN6.test(value)) {
       throw new Error("Learning candidate contains sensitive content.");
     }
     return;
@@ -13904,38 +13408,38 @@ function assertNoForbiddenContent2(value) {
       assertNoForbiddenContent2(item);
     return;
   }
-  if (!isRecord11(value))
+  if (!isRecord10(value))
     return;
   for (const [key, child] of Object.entries(value)) {
     const normalizedKey = normalizeKey2(key);
-    if (FORBIDDEN_RAW_KEYS4.has(normalizedKey)) {
+    if (FORBIDDEN_RAW_KEYS3.has(normalizedKey)) {
       throw new Error(`Learning candidate contains forbidden raw field: ${key}`);
     }
     assertNoForbiddenContent2(child);
   }
 }
-function sanitizeText4(value) {
-  return value.replace(SENSITIVE_TEXT_PATTERN7, "[redacted]").slice(0, 500);
+function sanitizeText3(value) {
+  return value.replace(SENSITIVE_TEXT_PATTERN6, "[redacted]").slice(0, 500);
 }
 function sanitizeNullableText(value) {
-  return value === null ? null : sanitizeText4(value);
+  return value === null ? null : sanitizeText3(value);
 }
-function sanitizeId4(value) {
-  const sanitized = sanitizeText4(value).replace(/\[redacted\]/gi, "redacted").replace(/[^a-zA-Z0-9._-]/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "").slice(0, 100);
+function sanitizeId3(value) {
+  const sanitized = sanitizeText3(value).replace(/\[redacted\]/gi, "redacted").replace(/[^a-zA-Z0-9._-]/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "").slice(0, 100);
   return sanitized || "learning-candidate";
 }
 function sanitizeNullableId(value) {
-  return value === null ? null : sanitizeId4(value);
+  return value === null ? null : sanitizeId3(value);
 }
 function normalizeKey2(key) {
   return key.toLowerCase().replace(/[^a-z0-9]/g, "");
 }
-function isRecord11(value) {
+function isRecord10(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 // packages/core/src/pack/index.ts
-import { readFile as readFile18, readdir as readdir12, stat as stat11 } from "node:fs/promises";
-import { isAbsolute as isAbsolute6, join as join21, relative as relative7, sep } from "node:path";
+import { readFile as readFile18, readdir as readdir13, stat as stat11 } from "node:fs/promises";
+import { isAbsolute as isAbsolute7, join as join21, relative as relative7, sep } from "node:path";
 
 // packages/core/src/protected-zones/index.ts
 var SENSITIVE_DIRECTORY_SEGMENTS = new Set([
@@ -14170,7 +13674,7 @@ async function planPackInstallDryRun(input) {
   };
 }
 function parsePackManifest(value) {
-  if (!isRecord12(value))
+  if (!isRecord11(value))
     throw new Error("Pack manifest must be an object.");
   const manifest = value;
   validateManifestTopLevelFields(manifest);
@@ -14180,14 +13684,14 @@ function parsePackManifest(value) {
   const description = requireString(manifest, "description");
   const publisher = optionalString6(manifest, "publisher");
   const license = optionalString6(manifest, "license");
-  const compatibility = requireRecord(manifest, "compatibility");
-  const assets = parseAssets(requireRecord(manifest, "assets"));
+  const compatibility = requireRecord2(manifest, "compatibility");
+  const assets = parseAssets(requireRecord2(manifest, "assets"));
   const permissions = parsePermissions(manifest.permissions);
-  const install = requireRecord(manifest, "install");
-  const verify = requireRecord(manifest, "verify");
-  const customizations = requireRecord(manifest, "customizations");
-  const observability = requireRecord(manifest, "observability");
-  const uninstall = requireRecord(manifest, "uninstall");
+  const install = requireRecord2(manifest, "install");
+  const verify = requireRecord2(manifest, "verify");
+  const customizations = requireRecord2(manifest, "customizations");
+  const observability = requireRecord2(manifest, "observability");
+  const uninstall = requireRecord2(manifest, "uninstall");
   validateCompatibilityTargets(id, requireStringArray(compatibility, "targets"));
   validateProtectedZoneDeclarations(manifest.protectedZones);
   if (observability.metadataOnly !== true) {
@@ -14225,7 +13729,7 @@ function parsePackManifest(value) {
       userPath: requireString(customizations, "userPath"),
       projectPath: requireString(customizations, "projectPath")
     },
-    protectedZones: isRecord12(manifest.protectedZones) ? {
+    protectedZones: isRecord11(manifest.protectedZones) ? {
       neverInclude: optionalStringArray(manifest.protectedZones, "neverInclude"),
       neverWrite: optionalStringArray(manifest.protectedZones, "neverWrite")
     } : undefined,
@@ -14415,7 +13919,7 @@ function validateGuideReferences(manifest, assets, findings) {
   }
 }
 async function collectPackRelativePaths(packRoot, dir = packRoot) {
-  const entries = await readdir12(dir, { withFileTypes: true });
+  const entries = await readdir13(dir, { withFileTypes: true });
   const paths3 = [];
   for (const entry of entries) {
     const absolutePath = join21(dir, entry.name);
@@ -14434,7 +13938,7 @@ function validatePackRelativePath(path, packRoot) {
   if (path.includes("\x00")) {
     return { severity: "error", code: "path-invalid", message: "Path must not contain NUL bytes." };
   }
-  if (isAbsolute6(path) || path.startsWith("~")) {
+  if (isAbsolute7(path) || path.startsWith("~")) {
     return {
       severity: "error",
       code: "path-absolute",
@@ -14451,7 +13955,7 @@ function validatePackRelativePath(path, packRoot) {
   }
   const absolute = join21(packRoot, normalized);
   const rel = relative7(packRoot, absolute);
-  if (rel === "" || rel.startsWith("..") || isAbsolute6(rel)) {
+  if (rel === "" || rel.startsWith("..") || isAbsolute7(rel)) {
     return {
       severity: "error",
       code: "path-traversal",
@@ -14496,7 +14000,7 @@ function parseAssets(value) {
 function parsePermissions(value) {
   if (value === undefined)
     return {};
-  if (!isRecord12(value))
+  if (!isRecord11(value))
     throw new Error("Pack manifest permissions must be an object.");
   const permissions = {};
   const knownKeys = new Set(Object.keys(RISKY_PERMISSION_LABELS));
@@ -14532,9 +14036,9 @@ function requireBoolean(record, key) {
     throw new Error(`Pack manifest missing boolean field: ${key}`);
   return value;
 }
-function requireRecord(record, key) {
+function requireRecord2(record, key) {
   const value = record[key];
-  if (!isRecord12(value))
+  if (!isRecord11(value))
     throw new Error(`Pack manifest missing object field: ${key}`);
   return value;
 }
@@ -14590,7 +14094,7 @@ function validateCompatibilityTargets(packId, targets) {
 function validateProtectedZoneDeclarations(value) {
   if (value === undefined)
     return;
-  if (!isRecord12(value))
+  if (!isRecord11(value))
     throw new Error("Pack manifest protectedZones must be an object.");
   const knownFields = new Set(["neverInclude", "neverWrite"]);
   for (const key of Object.keys(value)) {
@@ -14603,7 +14107,7 @@ function validateProtectedZoneDeclarations(value) {
 function isRemotePackInput(packPath) {
   return /^[a-z][a-z0-9+.-]*:\/\//i.test(packPath);
 }
-function isRecord12(value) {
+function isRecord11(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function normalizeRelativePath(path) {
@@ -14616,7 +14120,7 @@ function formatError(error) {
   return error instanceof Error ? error.message : String(error);
 }
 // packages/core/src/plugins/capabilities.ts
-import { mkdir as mkdir15, readFile as readFile19, writeFile as writeFile14 } from "node:fs/promises";
+import { mkdir as mkdir14, readFile as readFile19, writeFile as writeFile13 } from "node:fs/promises";
 import { dirname as dirname15, join as join22 } from "node:path";
 function createUnknownNegotiatedCapabilities(pluginId) {
   return {
@@ -14669,7 +14173,7 @@ function resolveNonCodexCapabilityState(supported, enabled) {
 }
 async function createCodexCapabilityVerificationArtifact(input) {
   const timestamp = input.createdAt ?? new Date().toISOString();
-  const detectionMessage = sanitizeText5(input.detection.message);
+  const detectionMessage = sanitizeText4(input.detection.message);
   const diagnostics = [
     "Codex skills are packaged in the EvoDev Codex plugin payload.",
     "Codex agents sync to user-level TOML files under ~/.codex/agents.",
@@ -14732,8 +14236,8 @@ function resolveCodexCapabilityArtifactPath(homeDir) {
 async function writeCodexCapabilityVerificationArtifact(homeDir, artifact) {
   validateCodexCapabilityVerificationArtifact(artifact);
   const path = resolveCodexCapabilityArtifactPath(homeDir);
-  await mkdir15(dirname15(path), { recursive: true });
-  await writeFile14(path, `${JSON.stringify(artifact, null, 2)}
+  await mkdir14(dirname15(path), { recursive: true });
+  await writeFile13(path, `${JSON.stringify(artifact, null, 2)}
 `, { encoding: "utf8", flag: "wx" });
   return path;
 }
@@ -14795,7 +14299,7 @@ async function runPluginConformance(plugin) {
   }
   return { ok: findings.length === 0, findings };
 }
-function sanitizeText5(value) {
+function sanitizeText4(value) {
   return value.replace(/https?:\/\/\S+|\b(secret|token|password|private|internal|api[_-]?key)\b/gi, "[redacted]").slice(0, 300);
 }
 function assertNoSensitiveContent(value) {
@@ -14864,364 +14368,8 @@ function createPluginRegistry(plugins = []) {
 function getEnabledPluginIds(settings) {
   return Object.entries(settings.plugins).filter(([, pluginSettings]) => pluginSettings.enabled).map(([pluginId]) => pluginId).sort((left, right) => left.localeCompare(right));
 }
-// packages/core/src/project/index.ts
-import { mkdir as mkdir16, readFile as readFile20, readdir as readdir13, stat as stat12, writeFile as writeFile15 } from "node:fs/promises";
-import { basename as basename5, join as join23, relative as relative8 } from "node:path";
-var PROJECT_CONTEXT_ALLOWED_RELATIVE_PATHS = [
-  ".evodev/project.json",
-  ".evodev/profile.md",
-  ".evodev/index.json",
-  ".evodev/commands.json",
-  ".evodev/privacy.json",
-  ".evodev/decisions/README.md"
-];
-var EXCLUDED_DIRECTORY_NAMES = new Set([
-  ".git",
-  ".claude",
-  ".codex",
-  "backups",
-  "build",
-  "coverage",
-  "dist",
-  "node_modules"
-]);
-var EXCLUDED_FILE_PREFIXES = [".env"];
-var EXCLUDED_FILE_PARTS = [
-  "api-key",
-  "api_key",
-  "apikey",
-  "credential",
-  "credentials",
-  "internal",
-  "internal-link",
-  "password",
-  "passwords",
-  "passwd",
-  "private",
-  "private-url",
-  "secret",
-  "token"
-];
-var EXCLUDED_FILE_EXTENSIONS = [".key", ".pem", ".p12", ".pfx"];
-var DOC_ENTRYPOINTS = new Set(["README.md"]);
-var DEFAULT_EXCLUDED_GLOBS = [
-  ".git/**",
-  "node_modules/**",
-  "dist/**",
-  "build/**",
-  "coverage/**",
-  ".env*",
-  "**/*secret*",
-  "**/*token*",
-  "**/*password*",
-  "**/*passwd*",
-  "**/*api-key*",
-  "**/*api_key*",
-  "**/*apikey*",
-  "**/*credential*",
-  "**/*private*",
-  "**/*internal*",
-  "**/*.key",
-  "**/*.pem",
-  ".claude/**",
-  ".codex/**",
-  ".evodev/backups/**"
-];
-var PROTECTED_PATTERNS = [
-  "secret",
-  "token",
-  "password",
-  "passwd",
-  "api-key",
-  "credential",
-  "private",
-  "private-url",
-  "internal",
-  "internal-link"
-];
-async function createProjectContextPlan(projectDir) {
-  const projectDirStat = await stat12(projectDir);
-  if (!projectDirStat.isDirectory()) {
-    throw new Error(`Project dir is not a directory: ${projectDir}`);
-  }
-  const projectId = createProjectId(projectDir);
-  const privacy = createProjectPrivacy();
-  const files = await collectProjectFileMetadata(projectDir);
-  const commands = await collectProjectCommands(projectDir);
-  const docs = files.filter((file) => file.kind === "file" && DOC_ENTRYPOINTS.has(basename5(file.path))).map((file) => file.path).sort();
-  const index = {
-    version: 1,
-    mode: "metadata-only",
-    projectId,
-    generatedAt: null,
-    rootName: basename5(projectDir),
-    files,
-    docs: { entrypoints: docs },
-    commands: {
-      scripts: commands.scripts,
-      testCommandCandidates: commands.scripts.filter((script) => script.commandClass === "test").map((script) => script.name)
-    },
-    exclusions: privacy.excludedGlobs,
-    sourceContentIncluded: false
-  };
-  const planFiles = await Promise.all(PROJECT_CONTEXT_ALLOWED_RELATIVE_PATHS.map(async (relativePath) => {
-    const absolutePath = join23(projectDir, relativePath);
-    const exists = await pathExists9(absolutePath);
-    return {
-      relativePath,
-      absolutePath,
-      action: exists ? "error" : "create",
-      reason: exists ? "Target already exists; I1 does not overwrite." : "Allowed project context file."
-    };
-  }));
-  const errors2 = planFiles.filter((file) => file.action === "error").map((file) => `${file.relativePath}: ${file.reason}`);
-  return {
-    projectDir,
-    projectId,
-    files: planFiles,
-    index,
-    commands,
-    privacy,
-    warnings: commands.warnings,
-    errors: errors2
-  };
-}
-async function writeProjectContext(plan) {
-  if (plan.errors.length > 0) {
-    throw new Error(`Cannot write project context:
-${plan.errors.join(`
-`)}`);
-  }
-  const payloads = createProjectContextPayloads(plan);
-  const writtenFiles = [];
-  for (const relativePath of PROJECT_CONTEXT_ALLOWED_RELATIVE_PATHS) {
-    const content = payloads[relativePath];
-    const absolutePath = join23(plan.projectDir, relativePath);
-    await mkdir16(join23(absolutePath, ".."), { recursive: true });
-    await writeFile15(absolutePath, content, { encoding: "utf8", flag: "wx" });
-    writtenFiles.push(relativePath);
-  }
-  return { writtenFiles };
-}
-function formatProjectContextPlan(plan, mode) {
-  return [
-    "EvoDev project init",
-    "",
-    `Mode: ${mode}`,
-    `Project: ${plan.projectDir}`,
-    `Project id: ${plan.projectId}`,
-    "",
-    "Plan:",
-    ...plan.files.map((file) => `  - ${file.action}: ${file.relativePath} (${file.reason})`),
-    "",
-    "Metadata-only index summary:",
-    `  - files: ${plan.index.files.filter((file) => file.kind === "file").length}`,
-    `  - directories: ${plan.index.files.filter((file) => file.kind === "directory").length}`,
-    `  - docs: ${plan.index.docs.entrypoints.length}`,
-    `  - package scripts: ${plan.commands.scripts.length}`,
-    ...plan.warnings.map((warning) => `Warning: ${warning}`),
-    ...plan.errors.map((error) => `Error: ${error}`)
-  ].join(`
-`);
-}
-function createProjectContextPayloads(plan) {
-  const profile = {
-    version: 1,
-    projectId: plan.projectId,
-    displayName: basename5(plan.projectDir),
-    root: { pathPolicy: "local-only" },
-    privacy: {
-      classification: "local-private",
-      metadataOnly: true,
-      sourceContentIncluded: false,
-      rawCommandsIncluded: false
-    }
-  };
-  return {
-    ".evodev/project.json": `${JSON.stringify(profile, null, 2)}
-`,
-    ".evodev/profile.md": createProfileMarkdown(plan),
-    ".evodev/index.json": `${JSON.stringify(plan.index, null, 2)}
-`,
-    ".evodev/commands.json": `${JSON.stringify(plan.commands, null, 2)}
-`,
-    ".evodev/privacy.json": `${JSON.stringify(plan.privacy, null, 2)}
-`,
-    ".evodev/decisions/README.md": `# Project Decisions
-
-Record project decisions here.
-`
-  };
-}
-function createProfileMarkdown(plan) {
-  return [
-    `# ${basename5(plan.projectDir)} Project Context`,
-    "",
-    "This project context was generated as metadata-only local state.",
-    "",
-    `- Project id: ${plan.projectId}`,
-    "- Source content included: false",
-    "- Raw package script commands included: false",
-    "- External upload: false",
-    ""
-  ].join(`
-`);
-}
-async function collectProjectFileMetadata(projectDir) {
-  const files = [];
-  async function visit(dir) {
-    const entries = await readdir13(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const absolutePath = join23(dir, entry.name);
-      const relativePath = relative8(projectDir, absolutePath).replaceAll("\\", "/");
-      if (shouldExcludePath(relativePath, entry.isDirectory())) {
-        continue;
-      }
-      if (entry.isDirectory()) {
-        files.push({ path: relativePath, kind: "directory" });
-        await visit(absolutePath);
-        continue;
-      }
-      if (entry.isFile()) {
-        const fileStat = await stat12(absolutePath);
-        files.push({ path: relativePath, kind: "file", sizeBytes: fileStat.size });
-      }
-    }
-  }
-  await visit(projectDir);
-  return files.sort((left, right) => left.path.localeCompare(right.path));
-}
-async function collectProjectCommands(projectDir) {
-  const packageJsonPath = join23(projectDir, "package.json");
-  const warnings = [];
-  if (!await pathExists9(packageJsonPath)) {
-    return { version: 1, metadataOnly: true, rawCommandsIncluded: false, scripts: [], warnings };
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(await readFile20(packageJsonPath, "utf8"));
-  } catch (error) {
-    warnings.push(`package.json scripts skipped: ${describeError4(error)}`);
-    return { version: 1, metadataOnly: true, rawCommandsIncluded: false, scripts: [], warnings };
-  }
-  const scripts = isRecord13(parsed) && isRecord13(parsed.scripts) ? parsed.scripts : {};
-  const summaries = [];
-  for (const [name, value] of Object.entries(scripts).sort(([left], [right]) => left.localeCompare(right))) {
-    if (typeof value !== "string") {
-      continue;
-    }
-    const commandClass = classifyScript(name, value);
-    const sensitiveReason = detectSensitiveScript(`${name} ${value}`);
-    if (sensitiveReason !== null) {
-      const safeName = `redacted-${commandClass}-script`;
-      const warning = `Protected ${commandClass} script name/command omitted because it matched protected pattern: ${sensitiveReason}.`;
-      warnings.push(warning);
-      summaries.push({
-        name: safeName,
-        commandClass,
-        summary: `Protected ${commandClass} script name/command omitted.`,
-        rawCommandStored: false,
-        redacted: true,
-        warning
-      });
-      continue;
-    }
-    summaries.push({
-      name,
-      commandClass,
-      summary: `Safe ${commandClass} script command summary only.`,
-      rawCommandStored: false,
-      redacted: false
-    });
-  }
-  return {
-    version: 1,
-    metadataOnly: true,
-    rawCommandsIncluded: false,
-    scripts: summaries,
-    warnings
-  };
-}
-function classifyScript(name, command) {
-  const text2 = `${name} ${command}`.toLowerCase();
-  if (text2.includes("typecheck") || text2.includes("tsc"))
-    return "typecheck";
-  if (text2.includes("lint") || text2.includes("biome") || text2.includes("eslint"))
-    return "lint";
-  if (text2.includes("test"))
-    return "test";
-  if (text2.includes("build"))
-    return "build";
-  if (text2.includes("format") || text2.includes("prettier"))
-    return "format";
-  if (text2.includes("install"))
-    return "install";
-  if (text2.includes("release") || text2.includes("publish") || text2.includes("pack"))
-    return "release";
-  return "other";
-}
-function detectSensitiveScript(command) {
-  const lower = command.toLowerCase();
-  if (/(^|[^a-z0-9])(secret|token|password|passwd|api[_-]?key|apikey|credential|credentials|private|internal|private-url|internal-link)([^a-z0-9]|$)/.test(lower))
-    return "protected-name-or-command";
-  if (/https?:\/\//i.test(command))
-    return "url";
-  if (/\b[a-z0-9._%+-]+@[a-z0-9.-]+\.[a-z]{2,}\b/i.test(command))
-    return "email-or-internal-id";
-  return null;
-}
-function createProjectPrivacy() {
-  return {
-    version: 1,
-    classification: "local-private",
-    metadataOnly: true,
-    sourceContentIndex: false,
-    promptHistoryIndex: false,
-    shellHistoryIndex: false,
-    rawCommandOutputIndex: false,
-    externalUpload: false,
-    excludedGlobs: DEFAULT_EXCLUDED_GLOBS,
-    protectedPatterns: PROTECTED_PATTERNS
-  };
-}
-function createProjectId(projectDir) {
-  return basename5(projectDir).toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "project";
-}
-function shouldExcludePath(relativePath, isDirectory) {
-  const segments = relativePath.split("/");
-  const name = segments.at(-1) ?? relativePath;
-  const lowerName = name.toLowerCase();
-  if (isDirectory && EXCLUDED_DIRECTORY_NAMES.has(name))
-    return true;
-  if (segments.includes(".evodev") && !relativePath.startsWith(".evodev/decisions"))
-    return true;
-  if (EXCLUDED_FILE_PREFIXES.some((prefix) => name.startsWith(prefix)))
-    return true;
-  if (EXCLUDED_FILE_PARTS.some((part) => lowerName.includes(part)))
-    return true;
-  if (EXCLUDED_FILE_EXTENSIONS.some((extension) => lowerName.endsWith(extension)))
-    return true;
-  return false;
-}
-async function pathExists9(path) {
-  try {
-    await stat12(path);
-    return true;
-  } catch (error) {
-    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
-      return false;
-    }
-    throw error;
-  }
-}
-function isRecord13(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function describeError4(error) {
-  return error instanceof Error ? error.message : String(error);
-}
 // packages/core/src/sync/orchestrator.ts
-import { join as join24 } from "node:path";
+import { join as join23 } from "node:path";
 async function runSync(options) {
   const store = createCoreConfigStore(options.homeDir);
   const settings = await store.readSettings();
@@ -15364,8 +14512,8 @@ function filterAssetsForTarget(assets, targetPlugin) {
 }
 function resolveAssetScannerPaths(assetsRootDir) {
   return {
-    skillsDir: join24(assetsRootDir, "skills"),
-    agentsDir: join24(assetsRootDir, "agents")
+    skillsDir: join23(assetsRootDir, "skills"),
+    agentsDir: join23(assetsRootDir, "agents")
   };
 }
 async function readRegistryOrDefault(store) {
@@ -15555,7 +14703,7 @@ async function handleTeamsMcpLine(line, options = {}) {
   try {
     return await handleTeamsMcpMessage(JSON.parse(line), options);
   } catch (error) {
-    return jsonRpcError(null, -32700, "Parse error", describeError5(error));
+    return jsonRpcError(null, -32700, "Parse error", describeError4(error));
   }
 }
 async function handleTeamsMcpMessage(message, options = {}) {
@@ -15575,7 +14723,7 @@ async function handleTeamsMcpMessage(message, options = {}) {
     }
     return jsonRpcError(request.id, -32601, `Method not found: ${request.method}`);
   } catch (error) {
-    return jsonRpcError(request.id, -32603, describeError5(error));
+    return jsonRpcError(request.id, -32603, describeError4(error));
   }
 }
 async function runTeamsMcpStdioServer(options = {}) {
@@ -15593,7 +14741,7 @@ async function runTeamsMcpStdioServer(options = {}) {
   }
 }
 function initializeResult(request) {
-  const params = isRecord14(request.params) ? request.params : {};
+  const params = isRecord12(request.params) ? request.params : {};
   const requestedVersion = typeof params.protocolVersion === "string" ? params.protocolVersion : PROTOCOL_VERSION;
   const protocolVersion = SUPPORTED_PROTOCOL_VERSIONS.has(requestedVersion) ? requestedVersion : PROTOCOL_VERSION;
   return {
@@ -15675,7 +14823,7 @@ function toolResult(structuredContent, isError = false) {
   };
 }
 function parseRequest(message) {
-  if (!isRecord14(message))
+  if (!isRecord12(message))
     throw new Error("Invalid JSON-RPC message; expected object.");
   if (message.jsonrpc !== "2.0")
     throw new Error("Invalid JSON-RPC version.");
@@ -15702,7 +14850,7 @@ function jsonRpcError(id, code, message, data) {
   return { jsonrpc: "2.0", id, error: { code, message, data } };
 }
 function expectRecord5(value, path) {
-  if (!isRecord14(value))
+  if (!isRecord12(value))
     throw new Error(`Invalid ${path}; expected object.`);
   return value;
 }
@@ -15715,28 +14863,28 @@ function expectString3(value, path) {
 function optionalString7(value) {
   return typeof value === "string" && value.length > 0 ? value : undefined;
 }
-function isRecord14(value) {
+function isRecord12(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function describeError5(error) {
+function describeError4(error) {
   return error instanceof Error ? error.message : String(error);
 }
 // packages/core/src/workflow/index.ts
-import { readFile as readFile21, readdir as readdir14 } from "node:fs/promises";
-import { join as join25 } from "node:path";
+import { readFile as readFile20, readdir as readdir14 } from "node:fs/promises";
+import { join as join24 } from "node:path";
 async function scanWorkflowManifests(workflowsDir) {
   const manifests = [];
   const entries = await readdir14(workflowsDir, { withFileTypes: true });
   for (const entry of entries) {
     if (!entry.isDirectory())
       continue;
-    const manifestPath = join25(workflowsDir, entry.name, "WORKFLOW.json");
-    manifests.push(parseWorkflowManifest(JSON.parse(await readFile21(manifestPath, "utf8"))));
+    const manifestPath = join24(workflowsDir, entry.name, "WORKFLOW.json");
+    manifests.push(parseWorkflowManifest(JSON.parse(await readFile20(manifestPath, "utf8"))));
   }
   return manifests.sort((left, right) => left.id.localeCompare(right.id));
 }
 function parseWorkflowManifest(value) {
-  if (!isRecord15(value))
+  if (!isRecord13(value))
     throw new Error("Workflow manifest must be an object.");
   const manifest = value;
   if (typeof manifest.id !== "string" || typeof manifest.version !== "string") {
@@ -15751,20 +14899,12 @@ function parseWorkflowManifest(value) {
   return manifest;
 }
 function planWorkflow(input) {
-  const mode = input.contract?.route.mode ?? null;
-  const warnings = [];
-  const advisories = [];
-  if (mode !== null && !input.workflow.modes.includes(mode)) {
-    advisories.push(`Workflow ${input.workflow.id} does not list task mode ${mode}.`);
-  }
   return {
     workflow: input.workflow,
-    taskId: input.contract?.taskId,
-    mode,
     steps: input.workflow.steps.map((step) => ({ ...step, plannedOnly: true })),
     requiredEvidence: input.workflow.requiredEvidence,
-    warnings,
-    advisories
+    warnings: [],
+    advisories: []
   };
 }
 function formatWorkflowList(manifests) {
@@ -15780,8 +14920,6 @@ function formatWorkflowPlan(plan) {
     "EvoDev workflow dry-run",
     "",
     `Workflow: ${plan.workflow.id}`,
-    `Task: ${plan.taskId ?? "none"}`,
-    `Mode: ${plan.mode ?? "not routed"}`,
     "",
     "Steps:",
     ...plan.steps.map((step) => `  - ${step.id}: ${step.name} [${step.actor}] evidence=${step.evidence.join(",") || "none"}`),
@@ -15793,13 +14931,11 @@ function formatWorkflowPlan(plan) {
   ].join(`
 `);
 }
-function isRecord15(value) {
+function isRecord13(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 export {
-  writeTaskContract,
   writeSessionIndex,
-  writeProjectContext,
   writeJson2 as writeJson,
   writeFailedOkfKnowledgePlanArtifact,
   writeEvolutionRepoProposal,
@@ -15809,7 +14945,6 @@ export {
   writeCodexCapabilityVerificationArtifact,
   writeCodeAgentTraceRef,
   withEvolutionReviewDecisionLock,
-  verifyTaskContract,
   validatePack,
   validateOkfKnowledgePlanContract,
   validateObservabilityEvent,
@@ -15848,7 +14983,6 @@ export {
   runSync,
   runPluginConformance,
   runDaemonForeground,
-  routeTaskContract,
   revokeOkfKnowledgeConcept,
   resumeTeamRun,
   resumeFailedOkfKnowledgePlan,
@@ -15858,9 +14992,10 @@ export {
   resolveTeamRole,
   resolveTeamOverlay,
   resolveTeamAgentReference,
-  resolveTaskContractOutputPath,
   resolveSessionMemoryPaths,
   resolveSegmentEvolutionTriggerPath,
+  resolveProjectWorkspaceFromCwd,
+  resolveProjectRegistryPaths,
   resolveProjectLogKey,
   resolveOkfKnowledgePaths,
   resolveObservabilityStorePaths,
@@ -15877,13 +15012,14 @@ export {
   resolveCodeAgentTraceRefPaths,
   renderRoleAgentDefinitionContext,
   renderMainTeamOverlayContext,
+  registerDiscoveredProject,
   recordTeamAgentNativeSession,
+  recordDiscoveredProject,
   recordCodeAgentTraceRefFromHook,
   reconcileTeamRun,
   rebuildOkfKnowledgeIndexes,
   readTeamAgentSummary,
   readTeamAgentDefinition,
-  readTaskContract,
   readSessionState,
   readSessionEvidenceSegment,
   readSessionCursor,
@@ -15909,7 +15045,7 @@ export {
   processEvolutionTriggers,
   planWorkflow,
   planPackInstallDryRun,
-  pathExists8 as pathExists,
+  pathExists7 as pathExists,
   parseWorkflowManifest,
   parseTeamRoleDefinition,
   parseTeamDefinitionMarkdown,
@@ -15936,14 +15072,17 @@ export {
   mergeAcceptedEvosCasesIntoKnowledgeQuery,
   markTeamMessagesDelivered,
   markOkfKnowledgeConceptStale,
+  markEvolutionRepoProposalApplied,
   loadAgentContextDryRun,
   loadAgentContext,
   loadActiveOkfKnowledgeIndex,
   listTeamRuns,
   listTeamRoleBindings,
   listTeamAgents,
+  listSessionMemoryStates,
   listSessionEvidenceSegments,
   listSegmentEvolutionTriggers,
+  listRegisteredProjects,
   listOkfKnowledgeConcepts,
   listObservabilityEvents,
   listLearningReviewDecisions,
@@ -15952,6 +15091,7 @@ export {
   listEvolutionKnowledgeReviewHistory,
   listEvolutionKnowledgeRecords,
   listEvolutionEvosCases,
+  listDiscoveredProjects,
   listCodeAgentTraceRefs,
   lintOkfKnowledge,
   lintLearningCandidates,
@@ -15973,10 +15113,8 @@ export {
   getEnabledPluginIds,
   formatWorkflowPlan,
   formatWorkflowList,
-  formatTaskContract,
   formatScopedKnowledgePromptBlock,
   formatRetentionDryRun,
-  formatProjectContextPlan,
   formatPackValidation,
   formatPackInstallDryRun,
   formatOkfKnowledgeQuery,
@@ -15998,7 +15136,6 @@ export {
   formatCodexCapabilityVerificationArtifact,
   formatAgentLoadedContextPromptBlock,
   formatAgentContextDryRun,
-  formatAgentComposeDryRun,
   findCandidateConflictOrDuplicate,
   exports_triggers as evolutionTriggers,
   exports_review as evolutionReview,
@@ -16019,9 +15156,7 @@ export {
   createTmuxRuntimeAdapter,
   createTeamRunStore,
   createTeamRoleRuntimeContext,
-  createTaskContract,
   createScopedKnowledgeContextPack,
-  createProjectContextPlan,
   createPluginRegistry,
   createOkfKnowledgePlanFromDistillationBatch,
   createObservabilityEvent,
@@ -16047,7 +15182,6 @@ export {
   createCodexCapabilityVerificationArtifact,
   createCodeAgentTraceRef,
   createCliLogEntry,
-  composeAgentDryRun,
   cleanupDaemonState,
   classifyCommandRisk,
   checkProtectedZonePaths,
@@ -16070,9 +15204,9 @@ export {
   TeamMessageBroker,
   TEAM_INTERNAL_WAKE_SIGNAL,
   SessionMemoryEvidenceError,
+  ProjectRegistrationError,
   PluginRegistryError,
   PluginRegistry,
-  PROJECT_CONTEXT_ALLOWED_RELATIVE_PATHS,
   NodeTeamRuntimeCommandRunner,
   EvoDevConfigError,
   EvoDevAssetError,