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

package/dist/index.js

@@ -59,10 +59,10 @@ __export(exports_knowledge, {
   assertOkfKnowledgePlanContract: () => assertOkfKnowledgePlanContract,
   activateOkfKnowledgePlan: () => activateOkfKnowledgePlan
 });
-import { createHash as createHash2 } from "node:crypto";
+import { createHash as createHash3 } from "node:crypto";
 import { existsSync, readFileSync, readdirSync } from "node:fs";
-import { mkdir as mkdir2, readFile as readFile3, readdir as readdir4, rename, rm, stat as stat2, writeFile as writeFile2 } from "node:fs/promises";
-import { dirname as dirname2, isAbsolute as isAbsolute2, join as join4, relative as relative2, resolve as resolve2 } from "node:path";
+import { mkdir as mkdir3, readFile as readFile3, readdir as readdir4, rename, rm as rm2, stat as stat2, writeFile as writeFile3 } from "node:fs/promises";
+import { dirname as dirname3, isAbsolute as isAbsolute2, join as join4, relative as relative2, resolve as resolve2 } from "node:path";
 
 // packages/core/src/config/paths.ts
 function resolveEvoDevPaths(homeDir = getHomeDir()) {
@@ -114,14 +114,19 @@ function stripTrailingSlash(path) {
 // packages/core/src/evolution/candidates/index.ts
 var exports_candidates = {};
 __export(exports_candidates, {
+  withEvolutionReviewDecisionLock: () => withEvolutionReviewDecisionLock,
+  updateEvolutionRepoProposalReviewState: () => updateEvolutionRepoProposalReviewState,
   updateEvolutionKnowledgeReviewState: () => updateEvolutionKnowledgeReviewState,
   readEvolutionReviewSnapshot: () => readEvolutionReviewSnapshot,
+  readEvolutionRepoProposalById: () => readEvolutionRepoProposalById,
   readEvolutionKnowledgeRecordById: () => readEvolutionKnowledgeRecordById,
+  listEvolutionKnowledgeReviewHistory: () => listEvolutionKnowledgeReviewHistory,
   listEvolutionKnowledgeRecords: () => listEvolutionKnowledgeRecords,
   listEvolutionEvosCases: () => listEvolutionEvosCases
 });
-import { readFile as readFile2, readdir as readdir3 } from "node:fs/promises";
-import { join as join3 } from "node:path";
+import { createHash as createHash2 } from "node:crypto";
+import { mkdir as mkdir2, readFile as readFile2, readdir as readdir3, rm, writeFile as writeFile2 } from "node:fs/promises";
+import { dirname as dirname2, join as join3 } from "node:path";
 
 // packages/core/src/utils/errors.ts
 function isNotFoundError(error) {
@@ -223,6 +228,7 @@ import { readdir as readdir2 } from "node:fs/promises";
 import { isAbsolute, relative, resolve } from "node:path";
 var MAX_EVIDENCE_EVENTS = 200;
 var MAX_TEXT_LENGTH = 600;
+var MAX_PROPOSED_CHANGE_LENGTH = 16 * 1024;
 var PROCESS_LOCK_STALE_MS = 5 * 60 * 1000;
 var REVIEW_STATES = [
   "auto-accepted",
@@ -524,7 +530,8 @@ function createEvolutionRepoProposal(input) {
     plannedFiles: input.plannedFiles.map((file) => ({
       relativePath: sanitizeRelativePath(file.relativePath),
       action: file.action,
-      reason: sanitizeText(file.reason)
+      reason: sanitizeText(file.reason),
+      ...file.proposedChange === undefined ? {} : { proposedChange: sanitizeProposedChange(file.proposedChange) }
     }))
   };
   validateEvolutionRepoProposal(proposal);
@@ -555,6 +562,27 @@ function validateEvolutionRepoProposal(proposal) {
     "deferred",
     "applied"
   ]);
+  if (proposal.reviewStateChangedAt !== undefined && Number.isNaN(new Date(proposal.reviewStateChangedAt).getTime())) {
+    throw new Error("Repo proposal reviewStateChangedAt must be a valid timestamp.");
+  }
+  for (const file of proposal.plannedFiles) {
+    if (file.proposedChange !== undefined && file.proposedChange.trim() === "") {
+      throw new Error("Repo proposal proposedChange must not be empty.");
+    }
+  }
+  if (proposal.lastDecision !== undefined) {
+    assertEnum("lastDecision.state", proposal.lastDecision.state, [
+      "accepted",
+      "rejected",
+      "deferred"
+    ]);
+    if (proposal.lastDecision.reason !== null && (proposal.lastDecision.reason.trim() === "" || proposal.lastDecision.reason.length > 500)) {
+      throw new Error("Repo proposal decision reason must be 1-500 characters.");
+    }
+    if (Number.isNaN(new Date(proposal.lastDecision.decidedAt).getTime())) {
+      throw new Error("Repo proposal decision timestamp must be valid.");
+    }
+  }
   if (proposal.apply.autoApply !== false || proposal.apply.requiresExplicitCommand !== true) {
     throw new Error("Repo proposal must require explicit apply.");
   }
@@ -562,6 +590,9 @@ function validateEvolutionRepoProposal(proposal) {
   assertProvenance(proposal.provenance);
   assertNoForbiddenRawFields(proposal);
 }
+function hasConcreteRepoProposalChanges(proposal) {
+  return proposal.targetRepoPath !== null && proposal.targetRepoPath.trim() !== "" && proposal.plannedFiles.length > 0 && proposal.plannedFiles.every((file) => file.proposedChange !== undefined && file.proposedChange.trim() !== "");
+}
 function validateEvolutionReviewCandidate(candidate) {
   if (!isRecord(candidate))
     throw new Error("Review candidate must be an object.");
@@ -580,8 +611,14 @@ function validateEvolutionReviewCandidate(candidate) {
   assertString("reviewCandidate.targetStore", candidate.targetStore);
   assertString("reviewCandidate.targetPath", candidate.targetPath);
   assertString("reviewCandidate.stableKey", candidate.stableKey);
-  if (candidate.reviewState !== "needs-human") {
-    throw new Error("Review candidate reviewState must be needs-human.");
+  assertEnum("reviewCandidate.reviewState", candidate.reviewState, [
+    "needs-human",
+    "accepted",
+    "rejected",
+    "deferred"
+  ]);
+  if (candidate.reviewStateChangedAt !== undefined && Number.isNaN(new Date(candidate.reviewStateChangedAt).getTime())) {
+    throw new Error("Review candidate reviewStateChangedAt must be a valid timestamp.");
   }
   if (!Array.isArray(candidate.reasons))
     throw new Error("Review candidate reasons must be an array.");
@@ -769,6 +806,12 @@ function assertNoForbiddenRawFields(value, path = "") {
 function sanitizeText(value) {
   return value.replace(SENSITIVE_TEXT_REPLACE_PATTERN, "[redacted]").replace(/\s+/g, " ").trim().slice(0, MAX_TEXT_LENGTH);
 }
+function sanitizeProposedChange(value) {
+  return value.replace(SENSITIVE_TEXT_REPLACE_PATTERN, "[redacted]").replaceAll(`\r
+`, `
+`).replaceAll("\r", `
+`).trim().slice(0, MAX_PROPOSED_CHANGE_LENGTH);
+}
 function sanitizeId(value) {
   return value.replace(/[^a-zA-Z0-9._/-]/g, "-").replace(/[\\/]+/g, "-").slice(0, 160) || "local";
 }
@@ -824,12 +867,14 @@ function resolveEvolutionPaths(input) {
   const projectKey = sanitizeStorageId2("projectKey", input.projectKey);
   const runId = sanitizeStorageId2("runId", input.runId);
   const evolutionStateDir = join2(paths.stateDir, "evolution");
+  const projectStateDir = join2(evolutionStateDir, projectKey);
   const runStateDir = join2(evolutionStateDir, projectKey, runId);
   const repoProposalsDir = join2(runStateDir, "proposals");
   const reviewCandidatesDir = join2(runStateDir, "review-candidates");
   const knowledgeProjectDir = join2(paths.knowledgeDir, projectKey);
   const evosCasesProjectDir = join2(paths.evosCasesDir, projectKey);
   assertPathDescendant(evolutionStateDir, runStateDir, "runStateDir");
+  assertPathDescendant(evolutionStateDir, projectStateDir, "projectStateDir");
   assertPathDescendant(evolutionStateDir, reviewCandidatesDir, "reviewCandidatesDir");
   assertPathDescendant(paths.knowledgeDir, knowledgeProjectDir, "knowledgeProjectDir");
   assertPathDescendant(paths.evosCasesDir, evosCasesProjectDir, "evosCasesProjectDir");
@@ -847,12 +892,40 @@ function resolveEvolutionPaths(input) {
     knowledgeProjectDir,
     knowledgeRecordsDir: join2(knowledgeProjectDir, "records"),
     knowledgeIndexPath: join2(knowledgeProjectDir, "index.json"),
+    knowledgeReviewHistoryPath: join2(projectStateDir, "knowledge-review-history.jsonl"),
     evosCasesProjectDir,
     evosIndexPath: paths.evosIndexPath
   };
 }
 
 // packages/core/src/evolution/candidates/index.ts
+var REVIEW_LOCK_WAIT_MS = 2000;
+var REVIEW_LOCK_RETRY_MS = 10;
+async function withEvolutionReviewDecisionLock(input, operation) {
+  const paths = resolveEvoDevPaths(input.homeDir);
+  const key = createHash2("sha256").update(`${input.kind}\x00${input.itemId}`).digest("hex");
+  const lockPath = join3(paths.stateDir, "evolution", ".review-locks", `${key}.lock`);
+  const deadline = Date.now() + REVIEW_LOCK_WAIT_MS;
+  await mkdir2(dirname2(lockPath), { recursive: true });
+  while (true) {
+    try {
+      await writeFile2(lockPath, `${JSON.stringify({ version: 1, kind: input.kind, acquiredAt: new Date().toISOString(), pid: process.pid })}
+`, { encoding: "utf8", flag: "wx" });
+      break;
+    } catch (error) {
+      if (!isAlreadyExistsError(error))
+        throw error;
+      if (Date.now() >= deadline)
+        throw new Error("Review decision lock is busy or stale.");
+      await sleep(REVIEW_LOCK_RETRY_MS);
+    }
+  }
+  try {
+    return await operation();
+  } finally {
+    await rm(lockPath, { force: true });
+  }
+}
 async function readEvolutionReviewSnapshot(input) {
   const paths = resolveEvoDevPaths(input.homeDir);
   const projectKeys = input.projectKey === undefined ? await listEvolutionReviewProjectKeys(paths) : [sanitizeStorageId2("projectKey", input.projectKey)];
@@ -905,6 +978,32 @@ async function listEvolutionKnowledgeRecords(input) {
     projectKey: input.projectKey
   })).knowledgeRecords.sort((left, right) => left.id.localeCompare(right.id));
 }
+async function listEvolutionKnowledgeReviewHistory(input) {
+  const paths = resolveEvoDevPaths(input.homeDir);
+  const projectKeys = input.projectKey === undefined ? await listDirectoryNames(join3(paths.stateDir, "evolution")) : [sanitizeStorageId2("projectKey", input.projectKey)];
+  const records = [];
+  for (const projectKey of projectKeys) {
+    const historyPath = resolveEvolutionPaths({
+      homeDir: input.homeDir,
+      projectKey,
+      runId: "review"
+    }).knowledgeReviewHistoryPath;
+    if (!await pathExists(historyPath))
+      continue;
+    for (const line of (await readFile2(historyPath, "utf8")).split(`
+`)) {
+      if (line.trim() === "")
+        continue;
+      records.push(parseKnowledgeReviewHistoryRecord(JSON.parse(line)));
+    }
+  }
+  return records.sort((left, right) => {
+    const changedAt = left.changedAt.localeCompare(right.changedAt);
+    if (changedAt !== 0)
+      return changedAt;
+    return left.knowledgeId.localeCompare(right.knowledgeId);
+  });
+}
 async function listEvolutionEvosCases(input) {
   const paths = resolveEvoDevPaths(input.homeDir);
   const projectKeys = input.projectKey === undefined ? await listDirectoryNames(paths.evosCasesDir) : [sanitizeStorageId2("projectKey", input.projectKey)];
@@ -955,44 +1054,186 @@ async function readEvolutionKnowledgeRecordById(input) {
   return matches[0];
 }
 async function updateEvolutionKnowledgeReviewState(input) {
-  const record = await readEvolutionKnowledgeRecordById(input);
-  const next = {
-    ...record,
-    reviewState: input.reviewState,
-    authority: input.reviewState === "accepted" ? "reviewed" : "contextual",
-    runtime: {
-      ...record.runtime,
-      canLoad: input.reviewState === "accepted",
-      hardBlocking: false
+  return await withEvolutionReviewDecisionLock({ homeDir: input.homeDir, kind: "knowledge", itemId: input.knowledgeId }, async () => {
+    const record = await readEvolutionKnowledgeRecordById(input);
+    if (input.expectedReviewState !== undefined && record.reviewState !== input.expectedReviewState) {
+      throw new Error("Knowledge review state changed before the decision was applied.");
     }
-  };
-  validateEvolutionKnowledgeRecord(next);
-  const paths = resolveEvolutionPaths({
+    const paths = resolveEvolutionPaths({
+      homeDir: input.homeDir,
+      projectKey: record.projectKey,
+      runId: "review"
+    });
+    const path = join3(paths.knowledgeRecordsDir, `${record.id}.json`);
+    if (record.reviewState === input.reviewState)
+      return { path, record, changed: false };
+    const changedAt = normalizeTimestamp2(input.now);
+    const next = {
+      ...record,
+      reviewState: input.reviewState,
+      authority: input.reviewState === "accepted" ? "reviewed" : "contextual",
+      runtime: {
+        ...record.runtime,
+        canLoad: false,
+        hardBlocking: false
+      }
+    };
+    validateEvolutionKnowledgeRecord(next);
+    await writeJsonFile(path, next, { overwrite: true });
+    const allProjectKnowledgeRecords = await readJsonFiles(paths.knowledgeRecordsDir, parseKnowledgeRecord);
+    await writeJsonFile(paths.knowledgeIndexPath, {
+      version: 1,
+      kind: "evolution-knowledge-index",
+      projectKey: next.projectKey,
+      updatedAt: changedAt,
+      records: allProjectKnowledgeRecords.map((item) => ({
+        id: item.id,
+        kind: item.kind,
+        title: item.title,
+        roleTags: item.roleTags,
+        tags: item.tags,
+        reviewState: item.reviewState,
+        authority: item.authority,
+        confidence: item.confidence,
+        runtime: item.runtime
+      }))
+    }, { overwrite: true });
+    const history = {
+      version: 1,
+      kind: "evolution-knowledge-review-state-changed",
+      knowledgeId: next.id,
+      projectKey: next.projectKey,
+      roleTags: uniqueSorted(next.roleTags),
+      artifactCreatedAt: next.provenance.createdAt,
+      previousReviewState: record.reviewState,
+      nextReviewState: next.reviewState,
+      changedAt,
+      metadataOnly: true
+    };
+    await mkdir2(dirname2(paths.knowledgeReviewHistoryPath), { recursive: true });
+    await writeFile2(paths.knowledgeReviewHistoryPath, `${JSON.stringify(history)}
+`, {
+      encoding: "utf8",
+      flag: "a"
+    });
+    return { path, record: next, changed: true };
+  });
+}
+async function readEvolutionRepoProposalById(input) {
+  const matches = (await readEvolutionReviewSnapshot({
     homeDir: input.homeDir,
-    projectKey: next.projectKey,
-    runId: "review"
+    projectKey: input.projectKey
+  })).repoProposals.filter((proposal) => proposal.id === input.proposalId);
+  if (matches.length === 0)
+    throw new Error(`Repo proposal not found: ${input.proposalId}`);
+  if (matches.length > 1) {
+    throw new Error(`Repo proposal id is ambiguous across runs: ${input.proposalId}`);
+  }
+  return matches[0];
+}
+async function updateEvolutionRepoProposalReviewState(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 review.");
+    }
+    const reason = input.reason?.trim();
+    if (input.reviewState === "rejected" && reason === undefined) {
+      throw new Error("Rejecting a repo proposal requires a reason.");
+    }
+    if (reason !== undefined && (reason === "" || reason.length > 500)) {
+      throw new Error("Repo proposal review reason must be 1-500 characters.");
+    }
+    if (input.expectedReviewState !== undefined && record.reviewState !== input.expectedReviewState) {
+      throw new Error("Repo proposal review state changed before the decision was 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 === input.reviewState)
+      return { path, record, changed: false };
+    const changedAt = normalizeTimestamp2(input.now);
+    const next = {
+      ...record,
+      reviewState: input.reviewState,
+      reviewStateChangedAt: changedAt,
+      lastDecision: {
+        state: input.reviewState,
+        reason: reason === undefined ? null : sanitizeText(reason),
+        decidedAt: changedAt
+      }
+    };
+    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 });
+    return { path, record: next, changed: true };
   });
-  const path = join3(paths.knowledgeRecordsDir, `${next.id}.json`);
-  await writeJsonFile(path, next, { overwrite: true });
-  const allProjectKnowledgeRecords = await readJsonFiles(paths.knowledgeRecordsDir, parseKnowledgeRecord);
-  await writeJsonFile(paths.knowledgeIndexPath, {
+}
+function parseKnowledgeReviewHistoryRecord(value) {
+  if (!isRecord2(value))
+    throw new Error("Knowledge review history record must be an object.");
+  const allowedKeys = new Set([
+    "version",
+    "kind",
+    "knowledgeId",
+    "projectKey",
+    "roleTags",
+    "artifactCreatedAt",
+    "previousReviewState",
+    "nextReviewState",
+    "changedAt",
+    "metadataOnly"
+  ]);
+  if (Object.keys(value).some((key) => !allowedKeys.has(key))) {
+    throw new Error("Knowledge review history record contains unsupported fields.");
+  }
+  if (value.version !== 1 || value.kind !== "evolution-knowledge-review-state-changed" || typeof value.knowledgeId !== "string" || typeof value.projectKey !== "string" || !Array.isArray(value.roleTags) || !value.roleTags.every((roleId) => typeof roleId === "string") || typeof value.artifactCreatedAt !== "string" || typeof value.previousReviewState !== "string" || !REVIEW_STATES.includes(value.previousReviewState) || typeof value.nextReviewState !== "string" || !REVIEW_STATES.includes(value.nextReviewState) || typeof value.changedAt !== "string" || value.metadataOnly !== true) {
+    throw new Error("Invalid knowledge review history record.");
+  }
+  normalizeTimestamp2(value.artifactCreatedAt);
+  normalizeTimestamp2(value.changedAt);
+  return {
     version: 1,
-    kind: "evolution-knowledge-index",
-    projectKey: next.projectKey,
-    updatedAt: new Date().toISOString(),
-    records: allProjectKnowledgeRecords.map((item) => ({
-      id: item.id,
-      kind: item.kind,
-      title: item.title,
-      roleTags: item.roleTags,
-      tags: item.tags,
-      reviewState: item.reviewState,
-      authority: item.authority,
-      confidence: item.confidence,
-      runtime: item.runtime
-    }))
-  }, { overwrite: true });
-  return { path, record: next };
+    kind: "evolution-knowledge-review-state-changed",
+    knowledgeId: sanitizeId(value.knowledgeId),
+    projectKey: sanitizeStorageId2("projectKey", value.projectKey),
+    roleTags: uniqueSorted(value.roleTags.map(sanitizeId)),
+    artifactCreatedAt: value.artifactCreatedAt,
+    previousReviewState: value.previousReviewState,
+    nextReviewState: value.nextReviewState,
+    changedAt: value.changedAt,
+    metadataOnly: true
+  };
+}
+function normalizeTimestamp2(value) {
+  const date = value === undefined ? new Date : value instanceof Date ? value : new Date(value);
+  if (Number.isNaN(date.getTime()))
+    throw new Error("Invalid knowledge review history timestamp.");
+  return date.toISOString();
+}
+function isAlreadyExistsError(error) {
+  return error instanceof Error && "code" in error && error.code === "EEXIST";
+}
+async function sleep(milliseconds) {
+  await new Promise((resolve2) => setTimeout(resolve2, milliseconds));
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
 // packages/core/src/evolution/knowledge/index.ts
@@ -1072,8 +1313,8 @@ function resolveOkfKnowledgePaths(homeDir) {
 async function ensureOkfKnowledgeBase(homeDir) {
   const paths = resolveOkfKnowledgePaths(homeDir);
   await ensureLocalKnowledgeGitRepository(paths.knowledgeDir);
-  await mkdir2(paths.indexesDir, { recursive: true });
-  await mkdir2(paths.tmpDir, { recursive: true });
+  await mkdir3(paths.indexesDir, { recursive: true });
+  await mkdir3(paths.tmpDir, { recursive: true });
   const directories = [
     {
       path: "",
@@ -1219,7 +1460,7 @@ function validateOkfKnowledgePlanContract(plan, _options = {}) {
   const add = (path, code, message, severity = "error") => {
     findings.push({ path, code, severity, message });
   };
-  if (!isRecord2(plan)) {
+  if (!isRecord3(plan)) {
     add("$", "plan.object", "Plan must be an object.");
     return { ok: false, findings };
   }
@@ -1255,7 +1496,7 @@ function validateOkfKnowledgePlanContract(plan, _options = {}) {
   }
   if (Array.isArray(plan.droppedSignals)) {
     plan.droppedSignals.forEach((signal, index) => {
-      if (!isRecord2(signal))
+      if (!isRecord3(signal))
         add(`droppedSignals[${index}]`, "signal.object", "Dropped signal must be an object.");
       if (!isNonEmptyString(signal?.evidenceRef)) {
         add(`droppedSignals[${index}].evidenceRef`, "signal.evidenceRef", "Dropped signal evidenceRef is required.");
@@ -1268,7 +1509,7 @@ function validateOkfKnowledgePlanContract(plan, _options = {}) {
   }
   if (Array.isArray(plan.conflicts)) {
     plan.conflicts.forEach((conflict, index) => {
-      if (!isRecord2(conflict))
+      if (!isRecord3(conflict))
         add(`conflicts[${index}]`, "conflict.object", "Conflict must be an object.");
       if (!isNonEmptyString(conflict?.candidateId)) {
         add(`conflicts[${index}].candidateId`, "conflict.candidateId", "Conflict candidateId is required.");
@@ -1329,7 +1570,7 @@ function normalizePlanCandidate(value, path) {
   return candidate;
 }
 function validateCandidateContract(candidate, path, evalSetIds, add) {
-  if (!isRecord2(candidate)) {
+  if (!isRecord3(candidate)) {
     add(path, "candidate.object", "Candidate must be an object.");
     return;
   }
@@ -1401,7 +1642,7 @@ function validateCandidateContract(candidate, path, evalSetIds, add) {
     if (!Array.isArray(candidate.evidenceRefs) || candidate.evidenceRefs.length === 0) {
       add(`${path}.evidenceRefs`, "candidate.active.evidenceRefs", "Active writes require evidenceRefs.");
     }
-    const verification = isRecord2(candidate.bodySections) && Array.isArray(candidate.bodySections.verification) ? candidate.bodySections.verification : [];
+    const verification = isRecord3(candidate.bodySections) && Array.isArray(candidate.bodySections.verification) ? candidate.bodySections.verification : [];
     if (verification.length === 0 && !isNonEmptyString(candidate.verificationNotApplicableReason)) {
       add(`${path}.bodySections.verification`, "candidate.active.verification", "Active writes require verification or an explicit not-applicable reason.");
     }
@@ -1581,7 +1822,7 @@ function normalizeEvalSetDecision(value) {
   return normalized;
 }
 function assertRecordValue(value, path) {
-  if (!isRecord2(value))
+  if (!isRecord3(value))
     throw new Error(`${path} must be an object.`);
   return value;
 }
@@ -1611,14 +1852,14 @@ function readScore(value, path) {
   }
   return value;
 }
-function isRecord2(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isNonEmptyString(value) {
   return typeof value === "string" && value.trim() !== "";
 }
 function validateEvidenceRefValue(evidenceRef, path, add) {
-  if (!isRecord2(evidenceRef)) {
+  if (!isRecord3(evidenceRef)) {
     add(path, "evidenceRef.object", "Evidence ref must be an object.");
     return;
   }
@@ -1635,13 +1876,13 @@ function validateEvidenceRefValue(evidenceRef, path, add) {
   }
 }
 function validateEvalSetValue(evalSet, path, add) {
-  if (!isRecord2(evalSet)) {
+  if (!isRecord3(evalSet)) {
     add(path, "evalSet.object", "Eval set must be an object.");
     return;
   }
   if (!isNonEmptyString(evalSet.id))
     add(`${path}.id`, "evalSet.id", "Eval set id is required.");
-  if (!isRecord2(evalSet.target)) {
+  if (!isRecord3(evalSet.target)) {
     add(`${path}.target`, "evalSet.target", "Eval set target is required.");
   } else {
     if (!isNonEmptyString(evalSet.target.kind))
@@ -1657,7 +1898,7 @@ function validateEvalSetValue(evalSet, path, add) {
   } else {
     evalSet.cases.forEach((item, index) => {
       const casePath = `${path}.cases[${index}]`;
-      if (!isRecord2(item)) {
+      if (!isRecord3(item)) {
         add(casePath, "evalSet.case.object", "Eval set case must be an object.");
         return;
       }
@@ -1670,7 +1911,7 @@ function validateEvalSetValue(evalSet, path, add) {
       }
     });
   }
-  if (!isRecord2(evalSet.privacy)) {
+  if (!isRecord3(evalSet.privacy)) {
     add(`${path}.privacy`, "evalSet.privacy", "Eval set privacy is required.");
   } else {
     if (evalSet.privacy.usesRawPrompt !== false)
@@ -1702,7 +1943,7 @@ function validateOverlayUpdatesValue(value, path, add) {
   }
   value.forEach((item, index) => {
     const itemPath = `${path}[${index}]`;
-    if (!isRecord2(item)) {
+    if (!isRecord3(item)) {
       add(itemPath, "overlayUpdate.object", "Overlay update must be an object.");
       return;
     }
@@ -1714,7 +1955,7 @@ function validateOverlayUpdatesValue(value, path, add) {
   });
 }
 function validateScoresValue(value, path, add) {
-  if (!isRecord2(value)) {
+  if (!isRecord3(value)) {
     add(path, "scores.object", "Scores must be an object.");
     return;
   }
@@ -1733,7 +1974,7 @@ function validateScoresValue(value, path, add) {
   }
 }
 function validatePrivacyCheckValue(value, path, add) {
-  if (!isRecord2(value)) {
+  if (!isRecord3(value)) {
     add(path, "privacy.object", "Privacy check must be an object.");
     return;
   }
@@ -1743,7 +1984,7 @@ function validatePrivacyCheckValue(value, path, add) {
   }
 }
 function validateBodySectionsValue(value, path, add) {
-  if (!isRecord2(value)) {
+  if (!isRecord3(value)) {
     add(path, "bodySections.object", "Body sections must be an object.");
     return;
   }
@@ -1772,7 +2013,7 @@ function validateTargetPathValue(value, path, requireMarkdown, add) {
   }
 }
 function isBehaviorChangeCandidate(candidate) {
-  if (!isRecord2(candidate))
+  if (!isRecord3(candidate))
     return false;
   const kind = typeof candidate.kind === "string" ? candidate.kind : "";
   const haystack = [
@@ -1892,10 +2133,10 @@ function decideOkfKnowledgeCandidate(candidate, context) {
   if (highRiskRequiresHuman) {
     return {
       ...sanitized,
-      decision: "needs-human",
+      decision: "no_write",
       scores,
-      reviewState: "needs-human",
-      decisionReason: "Needs human review: high-risk domain requires review."
+      reviewState: "auto-stored/unreviewed",
+      decisionReason: "No write: high-risk knowledge is not eligible for automatic activation."
     };
   }
   if (conflict?.kind === "duplicate") {
@@ -1911,10 +2152,10 @@ function decideOkfKnowledgeCandidate(candidate, context) {
   if (reusable) {
     return {
       ...sanitized,
-      decision: "needs-human",
+      decision: "no_write",
       scores,
-      reviewState: "needs-human",
-      decisionReason: conflict?.reason ?? explainNeedsHumanDecision(sanitized, scores, hasVerification, hasScopeTags)
+      reviewState: "auto-stored/unreviewed",
+      decisionReason: conflict?.reason ?? explainAutomaticNoWriteDecision(sanitized, scores, hasVerification, hasScopeTags)
     };
   }
   return {
@@ -1927,8 +2168,8 @@ function decideOkfKnowledgeCandidate(candidate, context) {
 }
 async function activateOkfKnowledgePlan(input) {
   const validation = validateOkfKnowledgePlanContract(input.plan);
-  const projectKey = isRecord2(input.plan) && isNonEmptyString(input.plan.projectKey) ? input.plan.projectKey : "unknown";
-  const runId = isRecord2(input.plan) && isNonEmptyString(input.plan.runId) ? input.plan.runId : "unknown";
+  const projectKey = isRecord3(input.plan) && isNonEmptyString(input.plan.projectKey) ? input.plan.projectKey : "unknown";
+  const runId = isRecord3(input.plan) && isNonEmptyString(input.plan.runId) ? input.plan.runId : "unknown";
   if (!validation.ok) {
     await writeFailedOkfKnowledgePlanArtifact({
       homeDir: input.homeDir,
@@ -1960,12 +2201,7 @@ async function activateOkfKnowledgePlan(input) {
         continue;
       }
       if (candidate.decision === "needs-human") {
-        await writeNeedsHumanKnowledgeCandidate({
-          homeDir: input.homeDir,
-          plan: input.plan,
-          candidate
-        });
-        needsHumanCandidates.push(candidate.id);
+        skippedCandidates.push(candidate.id);
         continue;
       }
       if (candidate.targetStore !== "okf") {
@@ -1979,10 +2215,10 @@ async function activateOkfKnowledgePlan(input) {
         await appendOkfLog(paths.okfDir, `**Skip**: Candidate \`${candidate.id}\` matched existing [${candidate.title}](${toOkfLink(paths.okfDir, targetPath)}).`);
         continue;
       }
-      await mkdir2(dirname2(targetPath), { recursive: true });
-      await writeFile2(targetPath, renderOkfConcept(candidate, input.plan), "utf8");
+      await mkdir3(dirname3(targetPath), { recursive: true });
+      await writeFile3(targetPath, renderOkfConcept(candidate, input.plan), "utf8");
       conceptPaths.push(targetPath);
-      affectedDirectories.add(dirname2(targetPath));
+      affectedDirectories.add(dirname3(targetPath));
       for (const update of candidate.overlayUpdates) {
         const overlayPath = resolveOkfTargetPath(paths.okfDir, update.targetPath);
         await ensureOverlayConcept({
@@ -1994,7 +2230,7 @@ async function activateOkfKnowledgePlan(input) {
           link: update.link
         });
         overlayPaths.push(overlayPath);
-        affectedDirectories.add(dirname2(overlayPath));
+        affectedDirectories.add(dirname3(overlayPath));
       }
     }
     const indexPaths = await regenerateOkfDirectoryIndexes(paths.okfDir);
@@ -2008,8 +2244,8 @@ async function activateOkfKnowledgePlan(input) {
       skippedCandidates,
       needsHumanCandidates
     });
-    await rm(tmpRunDir, { recursive: true, force: true });
-    await rm(failedPlanPath, { force: true });
+    await rm2(tmpRunDir, { recursive: true, force: true });
+    await rm2(failedPlanPath, { force: true });
     return {
       planPath,
       failedPlanPath,
@@ -2032,8 +2268,8 @@ async function activateOkfKnowledgePlan(input) {
       error: error instanceof Error ? error.message : String(error),
       failureKind: "organizer"
     });
-    await rm(tmpRunDir, { recursive: true, force: true });
-    await writeJson(join4(dirname2(failedPlanPath), "organizer-report.json"), {
+    await rm2(tmpRunDir, { recursive: true, force: true });
+    await writeJson(join4(dirname3(failedPlanPath), "organizer-report.json"), {
       schemaVersion: 1,
       kind: "okf-organizer-report",
       projectKey: input.plan.projectKey,
@@ -2079,7 +2315,7 @@ async function writeFailedOkfKnowledgePlanArtifact(input) {
 async function readFailedOkfKnowledgePlanArtifact(input) {
   const path = resolveFailedPlanPath(input.homeDir, input.projectKey, input.runId);
   const value = JSON.parse(await readFile3(path, "utf8"));
-  if (isRecord2(value) && value.kind === "okf-knowledge-failed-plan") {
+  if (isRecord3(value) && value.kind === "okf-knowledge-failed-plan") {
     const artifact = value;
     validateFailedPlanArtifact(artifact);
     return { path, artifact };
@@ -2113,12 +2349,12 @@ async function resumeFailedOkfKnowledgePlan(input) {
 }
 async function discardFailedOkfKnowledgePlan(input) {
   const path = resolveFailedPlanPath(input.homeDir, input.projectKey, input.runId);
-  await rm(path, { force: true });
+  await rm2(path, { force: true });
   return { path };
 }
 async function rebuildOkfKnowledgeIndexes(input) {
   const paths = resolveOkfKnowledgePaths(input.homeDir);
-  await mkdir2(paths.indexesDir, { recursive: true });
+  await mkdir3(paths.indexesDir, { recursive: true });
   const concepts = (await listOkfKnowledgeConcepts({ homeDir: input.homeDir })).filter(isActiveOkfConcept);
   const conceptSummaries = concepts.map((concept) => ({
     id: concept.id,
@@ -2703,7 +2939,7 @@ async function writeConceptLifecycleFrontmatter(input) {
   if (parsed === null)
     throw new Error(`OKF concept missing frontmatter: ${input.path}`);
   const frontmatter = upsertOkfLifecycleFrontmatter(parsed.frontmatter, input.reviewState, input.lifecycle);
-  await writeFile2(input.path, `---
+  await writeFile3(input.path, `---
 ${frontmatter.trimEnd()}
 ---
 ${parsed.body}`, "utf8");
@@ -2749,7 +2985,7 @@ function upsertOkfLifecycleFrontmatter(frontmatter, reviewState, lifecycle) {
 }
 async function appendLifecycleLogs(input) {
   const directories = [
-    ...new Set(input.conceptPaths.flatMap((path) => ancestorDirectories(input.okfDir, dirname2(path))))
+    ...new Set(input.conceptPaths.flatMap((path) => ancestorDirectories(input.okfDir, dirname3(path))))
   ];
   const logPaths = [];
   for (const directory of directories) {
@@ -2965,15 +3201,15 @@ function resolveFailedPlanPath(homeDir, projectKey, runId) {
   return path;
 }
 async function ensureLocalKnowledgeGitRepository(knowledgeDir) {
-  await mkdir2(knowledgeDir, { recursive: true });
+  await mkdir3(knowledgeDir, { recursive: true });
   const gitDir = join4(knowledgeDir, ".git");
   if (await pathExists2(gitDir))
     return;
-  await mkdir2(join4(gitDir, "objects", "info"), { recursive: true });
-  await mkdir2(join4(gitDir, "objects", "pack"), { recursive: true });
-  await mkdir2(join4(gitDir, "refs", "heads"), { recursive: true });
-  await mkdir2(join4(gitDir, "refs", "tags"), { recursive: true });
-  await mkdir2(join4(gitDir, "info"), { recursive: true });
+  await mkdir3(join4(gitDir, "objects", "info"), { recursive: true });
+  await mkdir3(join4(gitDir, "objects", "pack"), { recursive: true });
+  await mkdir3(join4(gitDir, "refs", "heads"), { recursive: true });
+  await mkdir3(join4(gitDir, "refs", "tags"), { recursive: true });
+  await mkdir3(join4(gitDir, "info"), { recursive: true });
   await writeTextIfMissing(join4(gitDir, "HEAD"), `ref: refs/heads/main
 `);
   await writeTextIfMissing(join4(gitDir, "config"), [
@@ -3016,8 +3252,8 @@ function assertPathDescendant2(root, candidate, field) {
 async function writeTextIfMissing(path, value) {
   if (await pathExists2(path))
     return;
-  await mkdir2(dirname2(path), { recursive: true });
-  await writeFile2(path, value, { encoding: "utf8", flag: "wx" });
+  await mkdir3(dirname3(path), { recursive: true });
+  await writeFile3(path, value, { encoding: "utf8", flag: "wx" });
 }
 function createCandidateFromEvosCase(evosCase) {
   const targetPath = `concepts/evos/${evosCase.id}.md`;
@@ -3078,49 +3314,6 @@ function createOverlayUpdates(projectKey, roleTags, workflowTags, sourceLink) {
     }))
   ];
 }
-async function writeNeedsHumanKnowledgeCandidate(input) {
-  const root = join4(resolveEvoDevPaths(input.homeDir).stateDir, "evolution");
-  const targetDir = join4(root, sanitizePlanStorageId("projectKey", input.plan.projectKey), sanitizePlanStorageId("runId", input.plan.runId), "review-candidates");
-  const targetPath = join4(targetDir, `${sanitizePlanStorageId("candidateId", input.candidate.id)}.json`);
-  assertPathDescendant2(root, targetPath, "reviewCandidatePath");
-  const candidateSnapshot = sanitizeReviewQueueValue(input.candidate);
-  await writeJson(targetPath, {
-    schemaVersion: 1,
-    kind: "evolution-review-candidate",
-    id: input.candidate.id,
-    projectKey: input.plan.projectKey,
-    runId: input.plan.runId,
-    createdAt: input.plan.createdAt,
-    candidateKind: input.candidate.kind,
-    title: sanitizeOkfText(input.candidate.title),
-    targetStore: input.candidate.targetStore,
-    targetPath: sanitizeOkfText(input.candidate.targetPath),
-    stableKey: sanitizeOkfText(input.candidate.stableKey),
-    reviewState: "needs-human",
-    reasons: [sanitizeOkfText(input.candidate.decisionReason)],
-    candidate: candidateSnapshot,
-    provenance: {
-      runId: input.plan.runId,
-      evidenceWindowId: input.plan.evidenceWindowId,
-      evidenceRefs: input.candidate.evidenceRefs.map(sanitizeOkfText),
-      createdBy: "evodev",
-      rawLogsStored: false,
-      rawPromptsStored: false,
-      sourceDumpsStored: false,
-      rawCommandOutputStored: false
-    },
-    privacy: {
-      classification: "local-private",
-      rawPromptsStored: false,
-      rawLogsStored: false,
-      sourceDumpsStored: false,
-      rawCommandOutputStored: false,
-      secretsStored: false,
-      internalLinksStored: false
-    }
-  }, { overwrite: true });
-  return targetPath;
-}
 function sanitizeOkfPlanCandidate(candidate) {
   return sanitizeReviewQueueValue(candidate);
 }
@@ -3143,9 +3336,9 @@ function hasUnsafeCandidateContent(candidate) {
   return FORBIDDEN_OKF_TEXT.test(content) || FORBIDDEN_OKF_FIELD.test(content) || PRIVATE_OR_INTERNAL_URL.test(content) || candidate.privacyCheck !== undefined && Object.values(candidate.privacyCheck).some((value) => value !== false);
 }
 function hasHighRiskHumanReviewSignal(candidate) {
-  if (!isRecord2(candidate))
+  if (!isRecord3(candidate))
     return false;
-  const body = isRecord2(candidate.bodySections) ? candidate.bodySections : {};
+  const body = isRecord3(candidate.bodySections) ? candidate.bodySections : {};
   const stringArray = (value) => Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
   const stringValue = (value) => typeof value === "string" ? value : "";
   const values = [
@@ -3174,7 +3367,7 @@ function hasHighRiskHumanReviewSignal(candidate) {
   ];
   return HUMAN_REVIEW_DOMAIN_PATTERN.test(values.join(" "));
 }
-function explainNeedsHumanDecision(candidate, scores, hasVerification, hasScopeTags) {
+function explainAutomaticNoWriteDecision(candidate, scores, hasVerification, hasScopeTags) {
   const reasons = [];
   if (candidate.targetStore !== "okf")
     reasons.push("target is not user-local OKF");
@@ -3194,7 +3387,7 @@ function explainNeedsHumanDecision(candidate, scores, hasVerification, hasScopeT
     reasons.push("stability is below auto-accept");
   if (scores.duplicationRisk > 2)
     reasons.push("duplication risk is above auto-accept");
-  return `Needs human review: ${reasons.join("; ") || "auto-accept gates were not all satisfied"}.`;
+  return `No write: ${reasons.join("; ") || "auto-accept gates were not all satisfied"}.`;
 }
 function resolveCandidateReviewStateForWrite(candidate) {
   if (candidate.reviewState === "auto-accepted" || candidate.decision === "auto-accept") {
@@ -3259,19 +3452,19 @@ async function ensureOverlayConcept(input) {
   const root = segments[0] ?? "repos";
   const scopeId = segments[1] ?? input.projectKey;
   const type = root === "roles" ? "EvoDev Role Attention" : root === "workflows" ? "EvoDev Workflow Attention" : "EvoDev Repo Attention";
-  await ensureOkfDirectory(input.okfDir, dirname2(relativePath), scopeId, `Attention overlay for ${scopeId}.`);
+  await ensureOkfDirectory(input.okfDir, dirname3(relativePath), scopeId, `Attention overlay for ${scopeId}.`);
   const exists = await pathExists2(input.overlayPath);
   const linkLine = `- [${input.candidate.title}](${input.link}) - ${input.candidate.description}`;
   if (exists) {
     const current = await readFile3(input.overlayPath, "utf8");
     if (current.includes(input.link))
       return;
-    await writeFile2(input.overlayPath, `${current.trimEnd()}
+    await writeFile3(input.overlayPath, `${current.trimEnd()}
 ${linkLine}
 `, "utf8");
     return;
   }
-  await writeFile2(input.overlayPath, [
+  await writeFile3(input.overlayPath, [
     "---",
     `type: ${yamlString(type)}`,
     `title: ${yamlString(`${scopeId} attention`)}`,
@@ -3416,11 +3609,11 @@ function renderOkfConcept(candidate, plan) {
 }
 async function ensureOkfDirectory(okfDir, relativeDir, title, description) {
   const dir = relativeDir === "" || relativeDir === "." ? okfDir : resolveOkfTargetPath(okfDir, relativeDir);
-  await mkdir2(dir, { recursive: true });
+  await mkdir3(dir, { recursive: true });
   const isRoot = dir === okfDir;
   const indexPath = join4(dir, "index.md");
   if (!await pathExists2(indexPath)) {
-    await writeFile2(indexPath, isRoot ? [
+    await writeFile3(indexPath, isRoot ? [
       "---",
       `okf_version: ${yamlString("0.1")}`,
       `title: ${yamlString(title)}`,
@@ -3437,7 +3630,7 @@ async function ensureOkfDirectory(okfDir, relativeDir, title, description) {
   }
   const logPath = join4(dir, "log.md");
   if (!await pathExists2(logPath)) {
-    await writeFile2(logPath, [
+    await writeFile3(logPath, [
       "# Directory Update Log",
       "",
       `## ${todayIsoDate()}`,
@@ -3488,7 +3681,7 @@ async function regenerateOkfDirectoryIndexes(okfDir) {
     ].join(`
 `);
     const indexPath = join4(directory, "index.md");
-    await writeFile2(indexPath, content, "utf8");
+    await writeFile3(indexPath, content, "utf8");
     paths.push(indexPath);
   }
   return paths;
@@ -3510,7 +3703,7 @@ function ancestorDirectories(root, directory) {
   const directories = [directory];
   let current = directory;
   while (current !== root && current.startsWith(root)) {
-    current = dirname2(current);
+    current = dirname3(current);
     directories.push(current);
   }
   return directories;
@@ -3519,20 +3712,20 @@ async function appendOkfLog(okfDir, entry) {
   await prependLogEntry(join4(okfDir, "log.md"), entry);
 }
 async function prependLogEntry(logPath, entry) {
-  await mkdir2(dirname2(logPath), { recursive: true });
+  await mkdir3(dirname3(logPath), { recursive: true });
   const date = todayIsoDate();
   const existing = await pathExists2(logPath) ? await readFile3(logPath, "utf8") : `# Directory Update Log
 `;
   const line = `* ${entry}`;
   if (existing.includes(`## ${date}`)) {
-    await writeFile2(logPath, existing.replace(`## ${date}
+    await writeFile3(logPath, existing.replace(`## ${date}
 `, `## ${date}
 ${line}
 `), "utf8");
     return;
   }
   const withoutTitle = existing.replace(/^# Directory Update Log\s*/u, "").trimStart();
-  await writeFile2(logPath, `${["# Directory Update Log", "", `## ${date}`, line, "", withoutTitle].join(`
+  await writeFile3(logPath, `${["# Directory Update Log", "", `## ${date}`, line, "", withoutTitle].join(`
 `).trimEnd()}
 `, "utf8");
 }
@@ -3624,7 +3817,7 @@ function createKnowledgeContextRevision(items) {
   }))))}`;
 }
 function sha256Short2(value) {
-  return createHash2("sha256").update(value).digest("hex").slice(0, 16);
+  return createHash3("sha256").update(value).digest("hex").slice(0, 16);
 }
 function stableJsonStringify(value) {
   if (value === null || typeof value !== "object")
@@ -3967,7 +4160,7 @@ function validateOkfKnowledgePlan(plan) {
   assertOkfKnowledgePlanContract(plan);
 }
 function validateFailedPlanArtifact(artifact) {
-  if (!isRecord2(artifact))
+  if (!isRecord3(artifact))
     throw new Error("Failed plan artifact must be an object.");
   if (artifact.schemaVersion !== 1)
     throw new Error("Failed plan artifact schemaVersion must be 1.");
@@ -3987,7 +4180,7 @@ function validateFailedPlanArtifact(artifact) {
   if (!Array.isArray(artifact.findings))
     throw new Error("Failed plan artifact findings must be an array.");
   for (const finding of artifact.findings) {
-    if (!isRecord2(finding))
+    if (!isRecord3(finding))
       throw new Error("Failed plan finding must be an object.");
     if (!isNonEmptyString(finding.path) || !isNonEmptyString(finding.code) || !isNonEmptyString(finding.message)) {
       throw new Error("Failed plan finding fields are required.");
@@ -4346,9 +4539,9 @@ function todayIsoDate() {
   return new Date().toISOString().slice(0, 10);
 }
 async function writeJson(path, value, options = {}) {
-  await mkdir2(dirname2(path), { recursive: true });
+  await mkdir3(dirname3(path), { recursive: true });
   const flag = options.overwrite === true ? "w" : "wx";
-  await writeFile2(path, `${JSON.stringify(value, null, 2)}
+  await writeFile3(path, `${JSON.stringify(value, null, 2)}
 `, { encoding: "utf8", flag });
 }
 async function pathExists2(path) {
@@ -4399,7 +4592,7 @@ function applyStrictestAgentPermissions(...permissions) {
   return merged;
 }
 function parseAgentProfile(value) {
-  if (!isRecord3(value))
+  if (!isRecord4(value))
     throw new Error("Agent profile must be an object.");
   if (value.version !== 1)
     throw new Error("Agent profile version must be 1.");
@@ -4534,7 +4727,7 @@ function validateAgentOutput(schema, output) {
   if (schema === "design-options-v1")
     return validateRequiredObject(output, ["summary", "options", "recommendation", "evidenceRefs"]);
   const errors2 = [];
-  if (!isRecord3(output))
+  if (!isRecord4(output))
     return { ok: false, errors: ["Output must be an object."] };
   if (typeof output.summary !== "string")
     errors2.push("summary is required.");
@@ -4707,7 +4900,7 @@ function collectPrivacyBoundaryAdvisories(contract, lenses, workflowId) {
   ] : [];
 }
 function validateRequiredObject(output, fields) {
-  if (!isRecord3(output))
+  if (!isRecord4(output))
     return { ok: false, errors: ["Output must be an object."] };
   const errors2 = fields.filter((field) => output[field] === undefined).map((field) => `${field} is required.`);
   return { ok: errors2.length === 0, errors: errors2 };
@@ -4733,7 +4926,7 @@ function assertStringArray(value, path) {
     throw new Error(`${path} must be an array of non-empty strings.`);
   }
 }
-function isRecord3(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 // packages/core/src/assets/errors.ts
@@ -4948,8 +5141,8 @@ __export(exports_code_agent_traces, {
   listCodeAgentTraceRefs: () => listCodeAgentTraceRefs,
   createCodeAgentTraceRef: () => createCodeAgentTraceRef
 });
-import { mkdir as mkdir4, readFile as readFile6, readdir as readdir6, stat as stat4, writeFile as writeFile3 } from "node:fs/promises";
-import { dirname as dirname4, isAbsolute as isAbsolute4, join as join7, normalize, relative as relative5 } from "node:path";
+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";
 
 // packages/core/src/runtime-logs/index.ts
 var exports_runtime_logs = {};
@@ -4967,8 +5160,8 @@ __export(exports_runtime_logs, {
   appendDebugLogEntry: () => appendDebugLogEntry,
   appendCliLogEntry: () => appendCliLogEntry
 });
-import { appendFile, mkdir as mkdir3 } from "node:fs/promises";
-import { dirname as dirname3, isAbsolute as isAbsolute3, join as join6, relative as relative4 } from "node:path";
+import { appendFile, mkdir as mkdir4 } from "node:fs/promises";
+import { dirname as dirname4, isAbsolute as isAbsolute3, join as join6, relative as relative4 } from "node:path";
 var MAX_LOG_STRING_LENGTH = 4096;
 var MAX_EVENT_STRING_LENGTH = 512;
 var MAX_DEBUG_ARRAY_LENGTH = 50;
@@ -5234,7 +5427,7 @@ function resolveProjectLogKey(homeDir, repoRoot) {
   return sanitizePersistentIdentifier(projectKey, "project");
 }
 function resolveTraceSessionKey(payload) {
-  const record = isRecord4(payload) ? payload : {};
+  const record = isRecord5(payload) ? payload : {};
   const sessionId = optionalString3(record.session_id ?? record.sessionId);
   const cwd = optionalString3(record.cwd);
   const source = sessionId ?? cwd ?? "local";
@@ -5299,7 +5492,7 @@ function sanitizeEvoDevExecutionEventForAppend(event) {
   });
 }
 async function appendJsonLine(path, value) {
-  await mkdir3(dirname3(path), { recursive: true });
+  await mkdir4(dirname4(path), { recursive: true });
   await appendFile(path, `${JSON.stringify(value)}
 `, "utf8");
 }
@@ -5380,7 +5573,7 @@ function sanitizeDebugValue(value, depth = 0) {
     }
     return items;
   }
-  if (isRecord4(value)) {
+  if (isRecord5(value)) {
     const output = {};
     const entries = Object.entries(value).slice(0, MAX_DEBUG_OBJECT_KEYS);
     for (const [key, nestedValue] of entries) {
@@ -5416,7 +5609,7 @@ function describeError(error) {
     return truncateString(error.message);
   return truncateString(String(error));
 }
-function isRecord4(value) {
+function isRecord5(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -5469,7 +5662,7 @@ function createCodeAgentTraceRef(input) {
   };
 }
 function parseCodeAgentTraceRef(value) {
-  if (!isRecord5(value))
+  if (!isRecord6(value))
     throw new Error("Code Agent trace ref must be an object.");
   if (value.version !== 1)
     throw new Error("Code Agent trace ref version must be 1.");
@@ -5508,8 +5701,8 @@ async function writeCodeAgentTraceRef(input) {
     target: ref.target,
     sessionKey: ref.sessionKey
   });
-  await mkdir4(dirname4(path), { recursive: true });
-  await writeFile3(path, `${JSON.stringify(ref, null, 2)}
+  await mkdir5(dirname5(path), { recursive: true });
+  await writeFile4(path, `${JSON.stringify(ref, null, 2)}
 `, "utf8");
   return { ref, path };
 }
@@ -5756,7 +5949,7 @@ function stripTrailingSlash3(path) {
 function isNotFoundError2(error) {
   return error instanceof Error && (("code" in error) && error.code === "ENOENT" || error.message.includes("ENOENT"));
 }
-function isRecord5(value) {
+function isRecord6(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 // packages/core/src/config/errors.ts
@@ -5837,10 +6030,19 @@ import { readFile as readFile12 } from "node:fs/promises";
 // packages/core/src/evolution/evidence/session-memory/index.ts
 var exports_session_memory = {};
 __export(exports_session_memory, {
+  writeSessionIndex: () => writeSessionIndex,
+  writeJson: () => writeJson2,
   updateSessionMemoryFromHook: () => updateSessionMemoryFromHook,
   resolveSessionMemoryPaths: () => resolveSessionMemoryPaths,
+  readSessionState: () => readSessionState,
+  readSessionEvidenceSegment: () => readSessionEvidenceSegment,
+  readSessionCursor: () => readSessionCursor,
+  readLineRange: () => readLineRange,
   parseSessionMemoryPolicy: () => parseSessionMemoryPolicy,
-  createDefaultSessionMemoryPolicy: () => createDefaultSessionMemoryPolicy
+  listSessionEvidenceSegments: () => listSessionEvidenceSegments,
+  createDefaultSessionMemoryPolicy: () => createDefaultSessionMemoryPolicy,
+  appendRawEvent: () => appendRawEvent,
+  SessionMemoryEvidenceError: () => SessionMemoryEvidenceError
 });
 
 // packages/core/src/evolution/evidence/session-memory/paths.ts
@@ -5890,8 +6092,208 @@ function parseSessionMemoryPolicy(value) {
     toolCallsBetweenUpdates: positiveInteger(value.toolCallsBetweenUpdates, defaults.toolCallsBetweenUpdates)
   };
 }
+// 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";
+
+// packages/core/src/evolution/evidence/session-memory/constants.ts
+var DEFAULT_MAX_RAW_EVENT_BYTES = 64 * 1024;
+var SENSITIVE_TEXT_PATTERN2 = /https?:\/\/\S+|\b(secret|token|password|passwd|private|internal|api[_-]?key|apikey|credential|credentials|\.env)\b/i;
+var EXPLICIT_MEMORY_PATTERN = /\b(remember|memorize|do not repeat|don't repeat|this is important|save this|learn this)\b/i;
+var FAILURE_PATTERN = /\b(fail|failed|failure|error|issue|exception|crash)\b/i;
+var VERIFICATION_PATTERN = /\b(test|lint|typecheck|build|verify|verification|passed|success)\b/i;
+
+// packages/core/src/evolution/evidence/session-memory/storage.ts
+class SessionMemoryEvidenceError extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "SessionMemoryEvidenceError";
+    this.code = code;
+  }
+}
+async function listSessionEvidenceSegments(input) {
+  const rootDir = join9(resolveEvoDevPaths(input.homeDir).stateDir, "session-memory");
+  const projectDirs = input.projectKey === undefined ? await listDirectoryNames2(rootDir) : [input.projectKey];
+  const segments = [];
+  for (const projectKey of projectDirs) {
+    const paths = resolveSessionMemoryPaths({
+      homeDir: input.homeDir,
+      projectKey,
+      sessionKey: "list"
+    });
+    for (const sessionKey of await listDirectoryNames2(paths.projectDir)) {
+      const sessionPaths = resolveSessionMemoryPaths({
+        homeDir: input.homeDir,
+        projectKey,
+        sessionKey
+      });
+      for (const entry of await listJsonFiles(sessionPaths.segmentsDir)) {
+        try {
+          segments.push(parseSessionEvidenceSegment(JSON.parse(await readFile7(entry, "utf8"))));
+        } catch {}
+      }
+    }
+  }
+  return segments.sort((left, right) => right.createdAt.localeCompare(left.createdAt));
+}
+async function readSessionEvidenceSegment(input) {
+  const paths = resolveSessionMemoryPaths(input);
+  try {
+    const segment = parseSessionEvidenceSegment(JSON.parse(await readFile7(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.");
+    }
+    return segment;
+  } catch (error) {
+    if (error instanceof SessionMemoryEvidenceError)
+      throw error;
+    if (isNotFoundError(error)) {
+      throw new SessionMemoryEvidenceError("not-found", "Session evidence segment was not found.");
+    }
+    throw new SessionMemoryEvidenceError("invalid", "Session evidence segment is invalid.");
+  }
+}
+async function readSessionState(path) {
+  try {
+    return JSON.parse(await readFile7(path, "utf8"));
+  } catch (error) {
+    if (isNotFoundError(error))
+      return null;
+    throw error;
+  }
+}
+async function readSessionCursor(path, sessionKey, sourcePath, now) {
+  try {
+    return JSON.parse(await readFile7(path, "utf8"));
+  } catch (error) {
+    if (!isNotFoundError(error))
+      throw error;
+    return {
+      schemaVersion: 1,
+      kind: "session-memory-cursor",
+      sessionKey,
+      traceRefId: null,
+      sourcePath,
+      lastCapturedOffset: null,
+      lastCapturedLine: null,
+      lastCapturedEventId: null,
+      updatedAt: now
+    };
+  }
+}
+async function appendRawEvent(path, event) {
+  const existingLineCount = await countJsonlLines(path);
+  await mkdir6(dirname6(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 lines = text2.split(`
+`).filter((line) => line.trim() !== "");
+  const selected = lines.slice(Math.max(0, fromLine - 1), toLine);
+  let secretsDetected = false;
+  for (const line of selected) {
+    try {
+      const parsed = JSON.parse(line);
+      secretsDetected = secretsDetected || parsed.secretsDetected === true;
+    } catch {
+      secretsDetected = secretsDetected || SENSITIVE_TEXT_PATTERN2.test(line);
+    }
+  }
+  return { content: selected.join(`
+`), truncated: false, secretsDetected };
+}
+async function writeSessionIndex(paths, state, segment, now) {
+  const existing = await readSessionIndex(paths.indexPath);
+  const segments = [
+    ...existing.segments.filter((item) => item.id !== segment.id),
+    {
+      id: segment.id,
+      reason: segment.reason,
+      strength: segment.strength,
+      createdAt: segment.createdAt,
+      reviewState: segment.lifecycle.reviewState
+    }
+  ];
+  await writeJson2(paths.indexPath, {
+    schemaVersion: 1,
+    kind: "session-memory-index",
+    projectKey: state.projectKey,
+    sessionKey: state.sessionKey,
+    updatedAt: now,
+    lastSegmentId: segment.id,
+    segments
+  });
+}
+async function writeJson2(path, value) {
+  await mkdir6(dirname6(path), { recursive: true });
+  await writeFile5(path, `${JSON.stringify(value, null, 2)}
+`, "utf8");
+}
+async function countJsonlLines(path) {
+  try {
+    const text2 = await readFile7(path, "utf8");
+    return text2.split(`
+`).filter((line) => line.trim() !== "").length;
+  } catch (error) {
+    if (isNotFoundError(error))
+      return 0;
+    throw error;
+  }
+}
+async function readSessionIndex(path) {
+  try {
+    const parsed = JSON.parse(await readFile7(path, "utf8"));
+    if (!Array.isArray(parsed.segments))
+      return { segments: [] };
+    return {
+      segments: parsed.segments.filter(isSessionIndexSegment)
+    };
+  } catch (error) {
+    if (isNotFoundError(error))
+      return { segments: [] };
+    throw error;
+  }
+}
+function isSessionIndexSegment(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return false;
+  const item = value;
+  return typeof item.id === "string" && typeof item.reason === "string" && typeof item.strength === "string" && typeof item.createdAt === "string" && typeof item.reviewState === "string";
+}
+function parseSessionEvidenceSegment(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new SessionMemoryEvidenceError("invalid", "Session evidence must be an object.");
+  }
+  const segment = value;
+  if (segment.schemaVersion !== 1 || segment.kind !== "session-evidence-segment" || typeof segment.id !== "string" || typeof segment.projectKey !== "string" || typeof segment.sessionKey !== "string" || typeof segment.createdAt !== "string" || typeof segment.normalized !== "object" || segment.normalized === null || typeof segment.rawExcerpt !== "object" || segment.rawExcerpt === null) {
+    throw new SessionMemoryEvidenceError("invalid", "Session evidence fields are invalid.");
+  }
+  return segment;
+}
+async function listDirectoryNames2(path) {
+  try {
+    return (await readdir7(path, { withFileTypes: true })).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort();
+  } catch (error) {
+    if (isNotFoundError(error))
+      return [];
+    throw error;
+  }
+}
+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();
+  } catch (error) {
+    if (isNotFoundError(error))
+      return [];
+    throw error;
+  }
+}
 // packages/core/src/evolution/evidence/session-memory/updater.ts
-import { join as join10 } from "node:path";
+import { join as join11 } from "node:path";
 
 // packages/core/src/evolution/triggers/index.ts
 var exports_triggers = {};
@@ -5906,8 +6308,8 @@ __export(exports_triggers, {
   enqueueSegmentEvolutionTrigger: () => enqueueSegmentEvolutionTrigger,
   enqueueEvolutionTrigger: () => enqueueEvolutionTrigger
 });
-import { readFile as readFile7 } from "node:fs/promises";
-import { join as join9 } from "node:path";
+import { readFile as readFile8 } from "node:fs/promises";
+import { join as join10 } from "node:path";
 
 // packages/core/src/evolution/triggers/classification.ts
 function normalizeEvolutionEventType(value) {
@@ -6042,19 +6444,19 @@ async function enqueueEvolutionTrigger(input) {
   };
   validateEvolutionTriggerRecord(trigger);
   const paths = resolveEvolutionPaths({ homeDir: input.homeDir, projectKey, runId });
-  await writeJsonFile(join9(paths.triggersDir, `${trigger.id}.json`), trigger, { overwrite: false });
+  await writeJsonFile(join10(paths.triggersDir, `${trigger.id}.json`), trigger, { overwrite: false });
   return trigger;
 }
 async function listEvolutionTriggers(input) {
   const paths = resolveEvoDevPaths(input.homeDir);
-  const evolutionStateDir = join9(paths.stateDir, "evolution");
+  const evolutionStateDir = join10(paths.stateDir, "evolution");
   const projectKeys = input.projectKey === undefined ? await listDirectoryNames(evolutionStateDir) : [sanitizeStorageId2("projectKey", input.projectKey)];
   const triggers = [];
   for (const projectKey of projectKeys) {
-    const projectStateDir = join9(evolutionStateDir, projectKey);
+    const projectStateDir = join10(evolutionStateDir, projectKey);
     const runIds = input.runId === undefined ? await listDirectoryNames(projectStateDir) : [sanitizeStorageId2("runId", input.runId)];
     for (const runId of runIds) {
-      const runTriggers = await readJsonFiles(join9(projectStateDir, runId, "triggers"), parseTrigger);
+      const runTriggers = await readJsonFiles(join10(projectStateDir, runId, "triggers"), parseTrigger);
       triggers.push(...runTriggers.filter((trigger) => input.status === undefined || trigger.status === input.status));
     }
   }
@@ -6095,16 +6497,16 @@ async function enqueueSegmentEvolutionTrigger(input) {
   } catch (error) {
     if (!isFileExistsError(error))
       throw error;
-    return parseSegmentTrigger(JSON.parse(await readFile7(path, "utf8")));
+    return parseSegmentTrigger(JSON.parse(await readFile8(path, "utf8")));
   }
 }
 async function listSegmentEvolutionTriggers(input) {
   const paths = resolveEvoDevPaths(input.homeDir);
-  const evolutionStateDir = join9(paths.stateDir, "evolution");
+  const evolutionStateDir = join10(paths.stateDir, "evolution");
   const projectKeys = input.projectKey === undefined ? await listDirectoryNames(evolutionStateDir) : [sanitizeStorageId2("projectKey", input.projectKey)];
   const triggers = [];
   for (const projectKey of projectKeys) {
-    const projectSegmentsDir = join9(evolutionStateDir, projectKey, "segments");
+    const projectSegmentsDir = join10(evolutionStateDir, projectKey, "segments");
     const projectTriggers = await readJsonFiles(projectSegmentsDir, parseSegmentTrigger);
     triggers.push(...projectTriggers.filter((trigger) => {
       if (input.status !== undefined && trigger.status !== input.status)
@@ -6141,7 +6543,7 @@ async function updateTriggers(homeDir, triggers, patch) {
       projectKey: next.projectKey,
       runId: next.runId
     });
-    await writeJsonFile(join9(paths.triggersDir, `${next.id}.json`), next, { overwrite: true });
+    await writeJsonFile(join10(paths.triggersDir, `${next.id}.json`), next, { overwrite: true });
   }
 }
 async function updateSegmentTriggers(homeDir, triggers, patch) {
@@ -6160,128 +6562,7 @@ async function updateSegmentTriggers(homeDir, triggers, patch) {
 }
 function resolveSegmentEvolutionTriggerPath(homeDir, trigger) {
   const paths = resolveEvoDevPaths(homeDir);
-  return join9(paths.stateDir, "evolution", sanitizeStorageId2("projectKey", trigger.projectKey), "segments", `${sanitizeStorageId2("segmentTrigger", trigger.id)}.json`);
-}
-
-// packages/core/src/evolution/evidence/session-memory/constants.ts
-var DEFAULT_MAX_RAW_EVENT_BYTES = 64 * 1024;
-var SENSITIVE_TEXT_PATTERN2 = /https?:\/\/\S+|\b(secret|token|password|passwd|private|internal|api[_-]?key|apikey|credential|credentials|\.env)\b/i;
-var EXPLICIT_MEMORY_PATTERN = /\b(remember|memorize|do not repeat|don't repeat|this is important|save this|learn this)\b/i;
-var FAILURE_PATTERN = /\b(fail|failed|failure|error|issue|exception|crash)\b/i;
-var VERIFICATION_PATTERN = /\b(test|lint|typecheck|build|verify|verification|passed|success)\b/i;
-
-// packages/core/src/evolution/evidence/session-memory/storage.ts
-import { appendFile as appendFile2, mkdir as mkdir5, readFile as readFile8, writeFile as writeFile4 } from "node:fs/promises";
-import { dirname as dirname5 } from "node:path";
-async function readSessionState(path) {
-  try {
-    return JSON.parse(await readFile8(path, "utf8"));
-  } catch (error) {
-    if (isNotFoundError(error))
-      return null;
-    throw error;
-  }
-}
-async function readSessionCursor(path, sessionKey, sourcePath, now) {
-  try {
-    return JSON.parse(await readFile8(path, "utf8"));
-  } catch (error) {
-    if (!isNotFoundError(error))
-      throw error;
-    return {
-      schemaVersion: 1,
-      kind: "session-memory-cursor",
-      sessionKey,
-      traceRefId: null,
-      sourcePath,
-      lastCapturedOffset: null,
-      lastCapturedLine: null,
-      lastCapturedEventId: null,
-      updatedAt: now
-    };
-  }
-}
-async function appendRawEvent(path, event) {
-  const existingLineCount = await countJsonlLines(path);
-  await mkdir5(dirname5(path), { recursive: true });
-  await appendFile2(path, `${JSON.stringify(event)}
-`, "utf8");
-  return { lineNumber: existingLineCount + 1 };
-}
-async function readLineRange(path, fromLine, toLine) {
-  const text2 = await readFile8(path, "utf8");
-  const lines = text2.split(`
-`).filter((line) => line.trim() !== "");
-  const selected = lines.slice(Math.max(0, fromLine - 1), toLine);
-  let secretsDetected = false;
-  for (const line of selected) {
-    try {
-      const parsed = JSON.parse(line);
-      secretsDetected = secretsDetected || parsed.secretsDetected === true;
-    } catch {
-      secretsDetected = secretsDetected || SENSITIVE_TEXT_PATTERN2.test(line);
-    }
-  }
-  return { content: selected.join(`
-`), truncated: false, secretsDetected };
-}
-async function writeSessionIndex(paths, state, segment, now) {
-  const existing = await readSessionIndex(paths.indexPath);
-  const segments = [
-    ...existing.segments.filter((item) => item.id !== segment.id),
-    {
-      id: segment.id,
-      reason: segment.reason,
-      strength: segment.strength,
-      createdAt: segment.createdAt,
-      reviewState: segment.lifecycle.reviewState
-    }
-  ];
-  await writeJson2(paths.indexPath, {
-    schemaVersion: 1,
-    kind: "session-memory-index",
-    projectKey: state.projectKey,
-    sessionKey: state.sessionKey,
-    updatedAt: now,
-    lastSegmentId: segment.id,
-    segments
-  });
-}
-async function writeJson2(path, value) {
-  await mkdir5(dirname5(path), { recursive: true });
-  await writeFile4(path, `${JSON.stringify(value, null, 2)}
-`, "utf8");
-}
-async function countJsonlLines(path) {
-  try {
-    const text2 = await readFile8(path, "utf8");
-    return text2.split(`
-`).filter((line) => line.trim() !== "").length;
-  } catch (error) {
-    if (isNotFoundError(error))
-      return 0;
-    throw error;
-  }
-}
-async function readSessionIndex(path) {
-  try {
-    const parsed = JSON.parse(await readFile8(path, "utf8"));
-    if (!Array.isArray(parsed.segments))
-      return { segments: [] };
-    return {
-      segments: parsed.segments.filter(isSessionIndexSegment)
-    };
-  } catch (error) {
-    if (isNotFoundError(error))
-      return { segments: [] };
-    throw error;
-  }
-}
-function isSessionIndexSegment(value) {
-  if (typeof value !== "object" || value === null || Array.isArray(value))
-    return false;
-  const item = value;
-  return typeof item.id === "string" && typeof item.reason === "string" && typeof item.strength === "string" && typeof item.createdAt === "string" && typeof item.reviewState === "string";
+  return join10(paths.stateDir, "evolution", sanitizeStorageId2("projectKey", trigger.projectKey), "segments", `${sanitizeStorageId2("segmentTrigger", trigger.id)}.json`);
 }
 
 // packages/core/src/evolution/evidence/session-memory/segment.ts
@@ -6379,8 +6660,8 @@ async function createSegment(input) {
       externalUploadAllowed: false
     },
     lifecycle: {
-      status: "pending-review",
-      reviewState: "unreviewed",
+      status: "captured",
+      reviewState: "not-required",
       consumedByBatchIds: []
     }
   };
@@ -6690,7 +6971,7 @@ async function updateSessionMemoryFromHook(input) {
   await writeJson2(paths.cursorPath, cursor);
   stateWrites.push(paths.statePath, paths.cursorPath);
   if (queuedSegmentTriggerId !== null) {
-    stateWrites.push(join10(input.homeDir, ".evodev", "state", "evolution", projectKey, "segments", `${queuedSegmentTriggerId}.json`));
+    stateWrites.push(join11(input.homeDir, ".evodev", "state", "evolution", projectKey, "segments", `${queuedSegmentTriggerId}.json`));
   }
   return {
     state,
@@ -6712,12 +6993,12 @@ function emptyResult() {
   };
 }
 // packages/core/src/hooks/index.ts
-import { mkdir as mkdir8, readFile as readFile11, writeFile as writeFile7 } from "node:fs/promises";
-import { dirname as dirname8, join as join13 } from "node:path";
+import { mkdir as mkdir9, readFile as readFile11, writeFile as writeFile8 } from "node:fs/promises";
+import { dirname as dirname9, join as join14 } from "node:path";
 
 // packages/core/src/task/index.ts
-import { lstat, mkdir as mkdir6, readFile as readFile9, realpath, stat as stat5, writeFile as writeFile5 } from "node:fs/promises";
-import { basename, dirname as dirname6, join as join11, resolve as resolve3 } from "node:path";
+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"]);
@@ -6917,8 +7198,8 @@ async function readTaskContract(path) {
 }
 async function writeTaskContract(path, contract, options = {}) {
   await assertTaskContractWritePathAllowed(path);
-  await mkdir6(dirname6(path), { recursive: true });
-  await writeFile5(path, `${JSON.stringify(contract, null, 2)}
+  await mkdir7(dirname7(path), { recursive: true });
+  await writeFile6(path, `${JSON.stringify(contract, null, 2)}
 `, {
     encoding: "utf8",
     flag: options.overwrite === true ? "w" : "wx"
@@ -6926,16 +7207,16 @@ async function writeTaskContract(path, contract, options = {}) {
 }
 async function resolveTaskContractOutputPath(input) {
   if (input.outputDir !== undefined) {
-    const outputPath = join11(input.outputDir, input.taskId, "contract.json");
+    const outputPath = join12(input.outputDir, input.taskId, "contract.json");
     await assertTaskContractWritePathAllowed(outputPath);
     return outputPath;
   }
   if (input.projectDir !== undefined) {
-    const projectContextPath = join11(input.projectDir, ".evodev", "project.json");
+    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 = join11(input.projectDir, ".evodev", "tasks", input.taskId, "contract.json");
+    const outputPath = join12(input.projectDir, ".evodev", "tasks", input.taskId, "contract.json");
     await assertTaskContractWritePathAllowed(outputPath);
     return outputPath;
   }
@@ -7140,7 +7421,7 @@ function isVerificationReady(contract) {
   return contract.status !== "draft" && contract.route.mode !== null && contract.route.workflowId !== null && (contract.route.requiredVerification ?? []).length > 0;
 }
 function parseTaskContract(value) {
-  if (!isRecord6(value) || value.version !== 1 || typeof value.taskId !== "string") {
+  if (!isRecord7(value) || value.version !== 1 || typeof value.taskId !== "string") {
     throw new Error("Invalid Task Contract JSON.");
   }
   return value;
@@ -7151,7 +7432,7 @@ function assertMetadataOnly(value) {
       assertMetadataOnly(item);
     return;
   }
-  if (!isRecord6(value)) {
+  if (!isRecord7(value)) {
     if (typeof value === "string" && containsSensitiveText(value)) {
       throw new Error("Verification input contains sensitive content in metadata field.");
     }
@@ -7229,11 +7510,11 @@ async function resolveTaskWriteRealPath(path) {
   while (true) {
     try {
       await lstat(currentPath);
-      return join11(await realpath(currentPath), ...missingSegments.reverse());
+      return join12(await realpath(currentPath), ...missingSegments.reverse());
     } catch (error) {
       if (!isMissingPathError(error))
         throw error;
-      const parentPath = dirname6(currentPath);
+      const parentPath = dirname7(currentPath);
       if (parentPath === currentPath)
         return resolve3(path);
       missingSegments.push(basename(currentPath));
@@ -7275,14 +7556,14 @@ async function pathExists4(path) {
 function isMissingPathError(error) {
   return error instanceof Error && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR");
 }
-function isRecord6(value) {
+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 mkdir7, readFile as readFile10, readdir as readdir7, stat as stat6, writeFile as writeFile6 } from "node:fs/promises";
-import { basename as basename2, dirname as dirname7, extname, isAbsolute as isAbsolute5, join as join12, relative as relative6, resolve as resolve4 } from "node:path";
+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";
 
 // packages/core/src/team/prompts.ts
 var TEAM_ROLE_STARTUP_PROMPT_TEMPLATE = [
@@ -7483,8 +7764,8 @@ function createTeamRunStore(homeDir) {
     paths: paths2,
     async createRunDirs(runId) {
       await migrateLegacyRunDirIfNeeded(paths2, runId);
-      await mkdir7(paths2.runDir(runId), { recursive: true });
-      await mkdir7(paths2.agentsDir(runId), { recursive: true });
+      await mkdir8(paths2.runDir(runId), { recursive: true });
+      await mkdir8(paths2.agentsDir(runId), { recursive: true });
     },
     async writeRun(run) {
       await this.createRunDirs(run.runId);
@@ -7495,7 +7776,7 @@ function createTeamRunStore(homeDir) {
       return parseTeamRunRecord(JSON.parse(await readFile10(paths2.runPath(runId), "utf8")));
     },
     async writeLatestRunId(runId) {
-      await mkdir7(paths2.runsDir, { recursive: true });
+      await mkdir8(paths2.runsDir, { recursive: true });
       await writeJson3(paths2.latestRunPath, { version: 1, runId });
     },
     async readLatestRunId() {
@@ -7529,8 +7810,8 @@ function createTeamRunStore(homeDir) {
     async readAgents(runId) {
       await migrateLegacyRunDirIfNeeded(paths2, runId);
       try {
-        const entries = await readdir7(paths2.agentsDir(runId));
-        const agents = await Promise.all(entries.filter((entry) => entry.endsWith(".json")).map((entry) => readFile10(join12(paths2.agentsDir(runId), entry), "utf8").then((raw) => parseTeamAgentRecord(JSON.parse(raw)))));
+        const entries = await readdir8(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 {
         return [];
@@ -7585,7 +7866,7 @@ function createTeamRunStore(homeDir) {
 }
 function resolveTeamRunPaths(homeDir) {
   const paths2 = resolveEvoDevPaths(homeDir);
-  const legacyRunsDir = join12(paths2.rootDir, "runs");
+  const legacyRunsDir = join13(paths2.rootDir, "runs");
   return {
     rootDir: paths2.rootDir,
     roleAgentsDir: paths2.roleAgentsDir,
@@ -7593,23 +7874,23 @@ function resolveTeamRunPaths(homeDir) {
     runsDir: paths2.runsDir,
     legacyRunsDir,
     latestRunPath: paths2.latestRunPath,
-    legacyLatestRunPath: join12(legacyRunsDir, "latest.json"),
-    runDir: (runId) => join12(paths2.runsDir, runId),
-    legacyRunDir: (runId) => join12(legacyRunsDir, runId),
-    runPath: (runId) => join12(paths2.runsDir, runId, "run.json"),
-    legacyRunPath: (runId) => join12(legacyRunsDir, runId, "run.json"),
-    tmuxPath: (runId) => join12(paths2.runsDir, runId, "tmux.json"),
-    legacyTmuxPath: (runId) => join12(legacyRunsDir, runId, "tmux.json"),
-    agentsDir: (runId) => join12(paths2.runsDir, runId, "agents"),
-    legacyAgentsDir: (runId) => join12(legacyRunsDir, runId, "agents"),
-    agentPath: (runId, roleId) => join12(paths2.runsDir, runId, "agents", `${roleId}.json`),
-    legacyAgentPath: (runId, roleId) => join12(legacyRunsDir, runId, "agents", `${roleId}.json`),
-    messagesPath: (runId) => join12(paths2.runsDir, runId, "messages.jsonl"),
-    legacyMessagesPath: (runId) => join12(legacyRunsDir, runId, "messages.jsonl"),
-    eventsPath: (runId) => join12(paths2.runsDir, runId, "events.jsonl"),
-    legacyEventsPath: (runId) => join12(legacyRunsDir, runId, "events.jsonl"),
-    statusPath: (runId) => join12(paths2.runsDir, runId, "status.json"),
-    messageListPath: (runId) => join12(paths2.runsDir, runId, "message-list.json")
+    legacyLatestRunPath: join13(legacyRunsDir, "latest.json"),
+    runDir: (runId) => join13(paths2.runsDir, runId),
+    legacyRunDir: (runId) => join13(legacyRunsDir, runId),
+    runPath: (runId) => join13(paths2.runsDir, runId, "run.json"),
+    legacyRunPath: (runId) => join13(legacyRunsDir, runId, "run.json"),
+    tmuxPath: (runId) => join13(paths2.runsDir, runId, "tmux.json"),
+    legacyTmuxPath: (runId) => join13(legacyRunsDir, runId, "tmux.json"),
+    agentsDir: (runId) => join13(paths2.runsDir, runId, "agents"),
+    legacyAgentsDir: (runId) => join13(legacyRunsDir, runId, "agents"),
+    agentPath: (runId, roleId) => join13(paths2.runsDir, runId, "agents", `${roleId}.json`),
+    legacyAgentPath: (runId, roleId) => join13(legacyRunsDir, runId, "agents", `${roleId}.json`),
+    messagesPath: (runId) => join13(paths2.runsDir, runId, "messages.jsonl"),
+    legacyMessagesPath: (runId) => join13(legacyRunsDir, runId, "messages.jsonl"),
+    eventsPath: (runId) => join13(paths2.runsDir, runId, "events.jsonl"),
+    legacyEventsPath: (runId) => join13(legacyRunsDir, runId, "events.jsonl"),
+    statusPath: (runId) => join13(paths2.runsDir, runId, "status.json"),
+    messageListPath: (runId) => join13(paths2.runsDir, runId, "message-list.json")
   };
 }
 async function migrateLegacyRunDirIfNeeded(paths2, runId) {
@@ -7619,7 +7900,7 @@ async function migrateLegacyRunDirIfNeeded(paths2, runId) {
   const legacyDir = paths2.legacyRunDir(runId);
   if (!await pathExists5(legacyDir))
     return;
-  await mkdir7(dirname7(nextDir), { recursive: true });
+  await mkdir8(dirname8(nextDir), { recursive: true });
   await cp(legacyDir, nextDir, { recursive: true, errorOnExist: false, force: false });
 }
 async function writeTeamStatusSnapshot(input) {
@@ -8149,7 +8430,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 readdir7(runsDir))
+      for (const entry of await readdir8(runsDir))
         entries.add(entry);
     } catch (error) {
       if (!isNotFoundError3(error))
@@ -8481,7 +8762,7 @@ async function listTeamAgents(input = {}) {
   }));
 }
 async function resolveTeamOverlay(input) {
-  const repoTeamPath = join12(input.repoRoot, ".evodev", "team", "team.md");
+  const repoTeamPath = join13(input.repoRoot, ".evodev", "team", "team.md");
   if (await pathExists5(repoTeamPath)) {
     return {
       source: "repo",
@@ -8508,7 +8789,7 @@ async function ensureDefaultTeamOverlay(input) {
   const paths2 = resolveEvoDevPaths(input.homeDir);
   const files = [];
   for (const asset of assets) {
-    const targetPath = asset.kind === "team" ? join12(paths2.rootDir, "team", "team.md") : join12(paths2.rootDir, "team", "agents", asset.name);
+    const targetPath = asset.kind === "team" ? join13(paths2.rootDir, "team", "team.md") : join13(paths2.rootDir, "team", "agents", asset.name);
     const content = await readFile10(asset.sourcePath, "utf8");
     files.push({
       sourcePath: asset.sourcePath,
@@ -8542,7 +8823,7 @@ function resolveTeamAgentReference(input) {
     return {
       roleId: input.roleId,
       reference,
-      sourcePath: join12(resolveEvoDevPaths(input.homeDir).rootDir, "team", "agents", `${name}.md`),
+      sourcePath: join13(resolveEvoDevPaths(input.homeDir).rootDir, "team", "agents", `${name}.md`),
       scope: "global"
     };
   }
@@ -8579,7 +8860,7 @@ async function readTeamAgentDefinition(input) {
   const reference = resolveTeamAgentReference(input);
   const markdown = await readTeamAgentMarkdown(reference);
   const parsed = parseMarkdownWithFrontmatter(markdown);
-  const evodev = isRecord7(parsed.frontmatter.evodev) ? parsed.frontmatter.evodev : {};
+  const evodev = isRecord8(parsed.frontmatter.evodev) ? parsed.frontmatter.evodev : {};
   return {
     roleId: input.roleId,
     name: optionalString5(parsed.frontmatter.name) ?? defaultRoleName(input.roleId),
@@ -8662,7 +8943,7 @@ async function resolveTeamRole(input) {
       nativeAgent: null
     };
   }
-  const globalRolePath = join12(resolveEvoDevPaths(input.homeDir).roleAgentsDir, `${input.roleId}.json`);
+  const globalRolePath = join13(resolveEvoDevPaths(input.homeDir).roleAgentsDir, `${input.roleId}.json`);
   const candidate = await readRoleCandidate(globalRolePath, "global");
   const nativeAgent = await resolveTeamRoleNativeAgentBinding({
     homeDir: input.homeDir,
@@ -8696,7 +8977,7 @@ async function resolveTeamRole(input) {
   };
 }
 function parseTeamRoleDefinition(value, defaults) {
-  const input = isRecord7(value) ? value : {};
+  const input = isRecord8(value) ? value : {};
   const roleId = optionalString5(input.roleId) ?? defaults.roleId;
   assertSafeId(roleId, "roleId");
   const runtime = parseRuntime(input.runtime, defaults.defaultRuntime);
@@ -9220,12 +9501,12 @@ async function readTeamOverlayAgentSummaries(input) {
   })));
 }
 async function listDefaultTeamOverlayAssets(assetsRootDir) {
-  const teamPath = join12(assetsRootDir, "team", "team.md");
-  const agentsDir = join12(assetsRootDir, "team", "agents");
+  const teamPath = join13(assetsRootDir, "team", "team.md");
+  const agentsDir = join13(assetsRootDir, "team", "agents");
   await assertReadableFile(teamPath, "Default team asset");
   let entries;
   try {
-    entries = await readdir7(agentsDir, { withFileTypes: true });
+    entries = await readdir8(agentsDir, { withFileTypes: true });
   } catch (error) {
     throw new Error(`Cannot read default team agents directory ${agentsDir}: ${describeError2(error)}`);
   }
@@ -9237,7 +9518,7 @@ async function listDefaultTeamOverlayAssets(assetsRootDir) {
     { kind: "team", sourcePath: teamPath, name: "team.md" },
     ...agentFiles.map((name) => ({
       kind: "agent",
-      sourcePath: join12(agentsDir, name),
+      sourcePath: join13(agentsDir, name),
       name
     }))
   ];
@@ -9260,8 +9541,8 @@ async function writeTextFileIfMissing(path, content) {
       throw new Error(`Cannot inspect ${path}: ${describeError2(error)}`);
     }
   }
-  await mkdir7(dirname7(path), { recursive: true });
-  await writeFile6(path, content.endsWith(`
+  await mkdir8(dirname8(path), { recursive: true });
+  await writeFile7(path, content.endsWith(`
 `) ? content : `${content}
 `, "utf8");
   return true;
@@ -9269,7 +9550,7 @@ async function writeTextFileIfMissing(path, content) {
 function parseTeamDefinitionAgents(value) {
   if (value === undefined)
     return {};
-  if (!isRecord7(value))
+  if (!isRecord8(value))
     throw new Error("team.md agents must be a role-id map.");
   const agents = {};
   for (const [roleId, reference] of Object.entries(value)) {
@@ -9335,7 +9616,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 (!isRecord7(parent))
+    if (!isRecord8(parent))
       throw new Error(`Invalid YAML parent for key ${key}.`);
     if (rawValue === "") {
       const next = findNextYamlContentLine(lines, index + 1);
@@ -9397,10 +9678,10 @@ function appendPromptBlock(prompt, block) {
 ${block.trim()}`;
 }
 function resolveGlobalTeamMarkdownPath(homeDir) {
-  return join12(resolveEvoDevPaths(homeDir).rootDir, "team", "team.md");
+  return join13(resolveEvoDevPaths(homeDir).rootDir, "team", "team.md");
 }
 function parseRolePermissions(value, main) {
-  const input = isRecord7(value) ? value : {};
+  const input = isRecord8(value) ? value : {};
   return {
     writeMode: parseWriteMode(input.writeMode, "repo-write"),
     canUseTeamsMcp: optionalBoolean2(input.canUseTeamsMcp) ?? true,
@@ -9409,14 +9690,14 @@ function parseRolePermissions(value, main) {
   };
 }
 function parseRolePolicy(value, recordTranscript) {
-  const input = isRecord7(value) ? value : {};
+  const input = isRecord8(value) ? value : {};
   return {
     roleInstancePolicy: "single-per-role",
     recordTranscript: optionalBoolean2(input.recordTranscript) ?? recordTranscript
   };
 }
 function parseTeamRunRecord(value) {
-  if (!isRecord7(value) || value.version !== 1)
+  if (!isRecord8(value) || value.version !== 1)
     throw new Error("Invalid team run record.");
   const run = value;
   assertSafeId(run.runId, "runId");
@@ -9426,7 +9707,7 @@ function parseTeamRunRecord(value) {
   return run;
 }
 function parseTeamAgentRecord(value) {
-  if (!isRecord7(value) || value.version !== 1)
+  if (!isRecord8(value) || value.version !== 1)
     throw new Error("Invalid team agent record.");
   const agent = value;
   assertSafeId(agent.agentId, "agentId");
@@ -9447,7 +9728,7 @@ function parseTeamAgentRecord(value) {
   ].includes(agent.status)) {
     throw new Error("Invalid agent status.");
   }
-  const nativeSessionValue = isRecord7(value.nativeSession) ? value.nativeSession : {};
+  const nativeSessionValue = isRecord8(value.nativeSession) ? value.nativeSession : {};
   return {
     ...agent,
     nativeSession: {
@@ -9457,7 +9738,7 @@ function parseTeamAgentRecord(value) {
   };
 }
 function parseTeamMessageRecord(value) {
-  if (!isRecord7(value) || value.version !== 1)
+  if (!isRecord8(value) || value.version !== 1)
     throw new Error("Invalid team message record.");
   const message = value;
   assertSafeId(message.messageId, "messageId");
@@ -9486,7 +9767,7 @@ function parseTeamPendingMessageRecord(value) {
   };
 }
 function parseTeamMessageListFile(value) {
-  if (!isRecord7(value) || value.version !== 1)
+  if (!isRecord8(value) || value.version !== 1)
     throw new Error("Invalid team message list.");
   const messages = Array.isArray(value.messages) ? value.messages.map(parseTeamPendingMessageRecord) : [];
   return {
@@ -9496,7 +9777,7 @@ function parseTeamMessageListFile(value) {
   };
 }
 function parseTeamEventRecord(value) {
-  if (!isRecord7(value) || value.version !== 1)
+  if (!isRecord8(value) || value.version !== 1)
     throw new Error("Invalid team event record.");
   const event = value;
   assertSafeId(event.eventId, "eventId");
@@ -9638,10 +9919,10 @@ async function resolveTeamRoleNativeAgentBinding(input) {
   return bindings.find((binding) => binding.roleId === input.roleId) ?? null;
 }
 function resolveGlobalTeamBindingPath(homeDir) {
-  return join12(resolveEvoDevPaths(homeDir).rootDir, "team", "roles.json");
+  return join13(resolveEvoDevPaths(homeDir).rootDir, "team", "roles.json");
 }
 function resolveProjectTeamBindingPath(homeDir, projectKey) {
-  return join12(resolveEvoDevPaths(homeDir).rootDir, "projects", safeSlug(projectKey), "team.json");
+  return join13(resolveEvoDevPaths(homeDir).rootDir, "projects", safeSlug(projectKey), "team.json");
 }
 function resolveTeamBindingWritePath(input) {
   if (input.scope === "global") {
@@ -9668,7 +9949,7 @@ async function readTeamBindingConfig(path) {
   }
 }
 function parseTeamBindingConfig(value) {
-  if (!isRecord7(value) || value.version !== 1)
+  if (!isRecord8(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 : [];
@@ -9679,7 +9960,7 @@ function parseTeamBindingConfig(value) {
   };
 }
 function parseTeamBindingRecord(value) {
-  if (!isRecord7(value) || value.version !== 1) {
+  if (!isRecord8(value) || value.version !== 1) {
     throw new Error("Invalid team binding record.");
   }
   const roleId = optionalString5(value.roleId);
@@ -9724,12 +10005,12 @@ async function pathExists5(path) {
   }
 }
 async function writeJson3(path, value) {
-  await mkdir7(dirname7(path), { recursive: true });
-  await writeFile6(path, `${JSON.stringify(value, null, 2)}
+  await mkdir8(dirname8(path), { recursive: true });
+  await writeFile7(path, `${JSON.stringify(value, null, 2)}
 `, "utf8");
 }
 async function appendJsonLine2(path, value) {
-  await mkdir7(dirname7(path), { recursive: true });
+  await mkdir8(dirname8(path), { recursive: true });
   await appendFile3(path, `${JSON.stringify(value)}
 `, "utf8");
 }
@@ -9767,7 +10048,7 @@ function optionalNullableString(value) {
 function optionalBoolean2(value) {
   return typeof value === "boolean" ? value : undefined;
 }
-function isRecord7(value) {
+function isRecord8(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function describeError2(error) {
@@ -9871,9 +10152,9 @@ function parseHookSettings(value) {
   const defaults = createDefaultHookSettings();
   if (value === undefined || value === null)
     return defaults;
-  if (!isRecord8(value))
+  if (!isRecord9(value))
     throw new Error("Invalid hooks settings; expected object.");
-  const observability = isRecord8(value.observability) ? value.observability : undefined;
+  const observability = isRecord9(value.observability) ? value.observability : undefined;
   optionalBoolean3(observability?.metadataOnly, defaults.observability.metadataOnly, "hooks.observability.metadataOnly");
   optionalBoolean3(observability?.rawPayloadStorage, defaults.observability.rawPayloadStorage, "hooks.observability.rawPayloadStorage");
   return {
@@ -10004,11 +10285,11 @@ function formatHookEventDryRun(event) {
 `);
 }
 function resolveHookRuntimeSessionPaths(input) {
-  const sessionDir = join13(input.homeDir, ".evodev", "STATE", "hooks", "sessions", input.sessionKey);
+  const sessionDir = join14(input.homeDir, ".evodev", "STATE", "hooks", "sessions", input.sessionKey);
   return {
     sessionDir,
-    bindingPath: join13(sessionDir, "binding.json"),
-    contractPath: join13(sessionDir, "contract.json")
+    bindingPath: join14(sessionDir, "binding.json"),
+    contractPath: join14(sessionDir, "contract.json")
   };
 }
 async function handleHookRuntime(input) {
@@ -10126,7 +10407,7 @@ async function recordEvolutionTriggerFromHook(input) {
       return { stateWrites: [], warnings: [] };
     return {
       stateWrites: [
-        join13(input.homeDir, ".evodev", "state", "evolution", trigger.projectKey, trigger.runId, "triggers", `${trigger.id}.json`)
+        join14(input.homeDir, ".evodev", "state", "evolution", trigger.projectKey, trigger.runId, "triggers", `${trigger.id}.json`)
       ],
       warnings: []
     };
@@ -10445,7 +10726,7 @@ function hookOutput(eventName, output) {
 function appendAdditionalContext(output, eventName, context) {
   if (output === null)
     return hookOutput(eventName, { additionalContext: context });
-  const hookSpecificOutput = isRecord8(output.hookSpecificOutput) ? output.hookSpecificOutput : {};
+  const hookSpecificOutput = isRecord9(output.hookSpecificOutput) ? output.hookSpecificOutput : {};
   const previous = typeof hookSpecificOutput.additionalContext === "string" ? hookSpecificOutput.additionalContext : "";
   return {
     ...output,
@@ -10594,8 +10875,8 @@ function resolveHookSessionKey(payload) {
   return `session-${sha256Short(source)}`;
 }
 async function writeJsonFile2(path, value) {
-  await mkdir8(dirname8(path), { recursive: true });
-  await writeFile7(path, `${JSON.stringify(value, null, 2)}
+  await mkdir9(dirname9(path), { recursive: true });
+  await writeFile8(path, `${JSON.stringify(value, null, 2)}
 `, "utf8");
 }
 function optionalPayloadString(value) {
@@ -10620,9 +10901,9 @@ function normalizeHookEventType(type, warnings) {
   throw new Error(`Unsupported hook event type: ${type}`);
 }
 function parseHookTargetSettings(value, defaults, target) {
-  const targets = isRecord8(value) ? value : {};
-  const targetSettings = isRecord8(targets[target]) ? targets[target] : {};
-  const events = isRecord8(targetSettings.events) ? targetSettings.events : {};
+  const targets = isRecord9(value) ? value : {};
+  const targetSettings = isRecord9(targets[target]) ? targets[target] : {};
+  const events = isRecord9(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}`);
@@ -10634,7 +10915,7 @@ function parseHookTargetSettings(value, defaults, target) {
 }
 function extractMetadata(type, payload, redactions) {
   const metadata = {};
-  const toolInput = isRecord8(payload.tool_input) ? payload.tool_input : isRecord8(payload.toolInput) ? payload.toolInput : {};
+  const toolInput = isRecord9(payload.tool_input) ? payload.tool_input : isRecord9(payload.toolInput) ? payload.toolInput : {};
   const toolName = optionalSanitizedString(payload.tool_name ?? payload.toolName, redactions);
   if (toolName !== null)
     metadata.toolName = toolName;
@@ -10712,7 +10993,7 @@ function optionalNumber(value) {
 function formatMetadataValue(value) {
   return Array.isArray(value) ? value.join(",") : String(value);
 }
-function isRecord8(value) {
+function isRecord9(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
@@ -11014,20 +11295,20 @@ function expectNonNegativeInteger(value, path) {
   return value;
 }
 // packages/core/src/config/store.ts
-import { mkdir as mkdir9, readFile as readFile13, writeFile as writeFile8 } from "node:fs/promises";
-import { dirname as dirname9 } from "node:path";
+import { mkdir as mkdir10, readFile as readFile13, writeFile as writeFile9 } from "node:fs/promises";
+import { dirname as dirname10 } from "node:path";
 function createCoreConfigStore(homeDir) {
   const paths2 = resolveEvoDevPaths(homeDir);
   return {
     paths: paths2,
     async ensureBaseDirs() {
-      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 });
+      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 });
     },
     async ensureKnowledgeBase() {
       await ensureKnowledgeBaseFiles(paths2);
@@ -11075,8 +11356,8 @@ async function initializeCoreConfig(homeDir) {
   return store;
 }
 async function ensureKnowledgeBaseFiles(paths2) {
-  await mkdir9(paths2.knowledgeDir, { recursive: true });
-  await mkdir9(paths2.evosCasesDir, { recursive: true });
+  await mkdir10(paths2.knowledgeDir, { recursive: true });
+  await mkdir10(paths2.evosCasesDir, { recursive: true });
   await ensureOkfKnowledgeBase(paths2.homeDir);
   await writeTextIfMissing2(`${paths2.knowledgeDir}/README.md`, [
     "# EvoDev Knowledge",
@@ -11205,7 +11486,7 @@ async function writeIndexIfMissingOrMigrate(filePath, kind, defaults) {
   } catch (error) {
     throw new EvoDevConfigError(`Invalid bootstrap index JSON (${describeFileError2(error)})`, filePath);
   }
-  if (!isRecord9(existing) || existing.kind !== kind)
+  if (!isRecord10(existing) || existing.kind !== kind)
     return;
   const migrated = { ...defaults, ...existing };
   if (Object.keys(defaults).every((key) => (key in existing)))
@@ -11217,16 +11498,16 @@ async function writeTextIfMissing2(filePath, value) {
     await readFile13(filePath, "utf8");
   } catch (error) {
     if (isNodeError2(error) && error.code === "ENOENT") {
-      await mkdir9(dirname9(filePath), { recursive: true });
-      await writeFile8(filePath, value, "utf8");
+      await mkdir10(dirname10(filePath), { recursive: true });
+      await writeFile9(filePath, value, "utf8");
       return;
     }
     throw new EvoDevConfigError(`Cannot inspect config file (${describeFileError2(error)})`, filePath);
   }
 }
 async function writeJsonFile3(filePath, value) {
-  await mkdir9(dirname9(filePath), { recursive: true });
-  await writeFile8(filePath, `${JSON.stringify(value, null, 2)}
+  await mkdir10(dirname10(filePath), { recursive: true });
+  await writeFile9(filePath, `${JSON.stringify(value, null, 2)}
 `, "utf8");
 }
 function describeFileError2(error) {
@@ -11238,14 +11519,14 @@ function describeFileError2(error) {
 function isNodeError2(error) {
   return error instanceof Error && "code" in error;
 }
-function isRecord9(value) {
+function isRecord10(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 // packages/core/src/daemon/index.ts
 import { randomBytes } from "node:crypto";
-import { mkdir as mkdir12, readFile as readFile16, readdir as readdir10, rm as rm3, stat as stat9, writeFile as writeFile11 } from "node:fs/promises";
+import { mkdir as mkdir13, readFile as readFile16, readdir as readdir11, rm as rm4, stat as stat9, writeFile as writeFile12 } from "node:fs/promises";
 import { createServer } from "node:http";
-import { dirname as dirname12, join as join18 } from "node:path";
+import { dirname as dirname13, join as join19 } from "node:path";
 
 // packages/core/src/evolution/control/index.ts
 var exports_control = {};
@@ -11386,6 +11667,7 @@ function formatEvolutionReviewSnapshot(snapshot) {
 // packages/core/src/evolution/processor/index.ts
 var exports_processor = {};
 __export(exports_processor, {
+  writeEvolutionRepoProposal: () => writeEvolutionRepoProposal,
   writeEvolutionDistillationBatch: () => writeEvolutionDistillationBatch,
   processEvolutionTriggers: () => processEvolutionTriggers,
   createEvolutionDistillationBatch: () => createEvolutionDistillationBatch,
@@ -11394,8 +11676,8 @@ __export(exports_processor, {
 });
 
 // packages/core/src/evolution/evidence/analysis.ts
-import { readFile as readFile14, readdir as readdir8 } from "node:fs/promises";
-import { basename as basename3, join as join14 } from "node:path";
+import { readFile as readFile14, readdir as readdir9 } from "node:fs/promises";
+import { basename as basename3, join as join15 } from "node:path";
 async function analyzeEvolutionRun(input) {
   const projectKey = resolveEvolutionProjectKey(input);
   const runId = sanitizeId(input.runId);
@@ -11405,17 +11687,17 @@ async function analyzeEvolutionRun(input) {
   const linkedTraceRefIds = new Set;
   const events = [];
   const logsDir = resolveEvoDevPaths(input.homeDir).logsDir;
-  const projectRunAgentsDir = join14(logsDir, "teams", projectKey, runId, "agents");
-  const legacyProjectRunAgentsDir = join14(logsDir, projectKey, runId, "agents");
-  const agentDirs = await pathExists(projectRunAgentsDir) ? await readdir8(projectRunAgentsDir, { withFileTypes: true }) : [];
-  const legacyAgentDirs = await pathExists(legacyProjectRunAgentsDir) ? await readdir8(legacyProjectRunAgentsDir, { withFileTypes: true }) : [];
+  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 }) : [];
   if (agentDirs.length === 0 && legacyAgentDirs.length === 0) {
     warnings.push(`No agent execution event directory found: ${displayPath(input.homeDir, projectRunAgentsDir)}`);
   } else {
     const rolesWithExecutionEvents = new Set;
     for (const roleDir of agentDirs.filter((entry) => entry.isDirectory())) {
       const roleId = sanitizeId(roleDir.name);
-      const eventsPath = join14(projectRunAgentsDir, roleDir.name, "events.jsonl");
+      const eventsPath = join15(projectRunAgentsDir, roleDir.name, "events.jsonl");
       if (!await pathExists(eventsPath))
         continue;
       rolesWithExecutionEvents.add(roleId);
@@ -11443,7 +11725,7 @@ async function analyzeEvolutionRun(input) {
       const roleId = sanitizeId(roleDir.name);
       if (rolesWithExecutionEvents.has(roleId))
         continue;
-      const tracePath = join14(legacyProjectRunAgentsDir, roleDir.name, "trace.log");
+      const tracePath = join15(legacyProjectRunAgentsDir, roleDir.name, "trace.log");
       if (!await pathExists(tracePath))
         continue;
       const sourceRef = {
@@ -11807,7 +12089,7 @@ function resolveEvolutionProjectKey(input) {
   throw new Error("Missing project scope: pass --project <projectKey> or --project-dir <path>.");
 }
 // packages/core/src/evolution/processor/distillation.ts
-import { join as join15 } from "node:path";
+import { join as join16 } from "node:path";
 function createEvolutionDistillationBatch(input) {
   validateEvolutionEvidenceWindow(input.evidenceWindow);
   const createdAt = normalizeTimestamp(input.now);
@@ -11839,7 +12121,7 @@ function createEvolutionDistillationBatch(input) {
       relations: {
         relatedKnowledgeIds: [],
         evosCaseIds: [createStableId("evo", [input.evidenceWindow.id, "case"])],
-        proposalIds: failedSignals.length === 0 ? [] : [createStableId("proposal", [input.evidenceWindow.id, "engineering-practice"])],
+        proposalIds: [],
         supersedes: []
       },
       privacy: createPrivacyFields(),
@@ -11876,29 +12158,7 @@ function createEvolutionDistillationBatch(input) {
       privacy: createPrivacyFields()
     })
   ];
-  const repoProposals = failedSignals.length === 0 ? [] : [
-    createEvolutionRepoProposal({
-      id: createStableId("proposal", [input.evidenceWindow.id, "engineering-practice"]),
-      kind: "engineering-practice",
-      projectKey: input.evidenceWindow.projectKey,
-      title: `Review repeated failure signals for ${input.evidenceWindow.runId}`,
-      summary: "Failure or issue signals appeared in redacted run evidence; review whether repository rules, tests, skills, or role agents need improvement.",
-      rationale: "EvoDev stores this as a proposal only. It must not modify the user repository until an explicit apply command is implemented and invoked.",
-      roleTags: roleIds,
-      tags: ["proposal", "failure-signal"],
-      reviewState: "pending",
-      confidence: "low",
-      targetRepoPath: null,
-      plannedFiles: [],
-      apply: {
-        autoApply: false,
-        requiresExplicitCommand: true,
-        rollbackPlan: "No repository files are changed by this proposal."
-      },
-      provenance: createProvenance(input.evidenceWindow, createdAt, sourceRefs),
-      privacy: createPrivacyFields()
-    })
-  ];
+  const repoProposals = [];
   const batch = {
     schemaVersion: 1,
     id: createStableId("batch", [input.evidenceWindow.id, createdAt]),
@@ -11926,19 +12186,19 @@ async function writeEvolutionDistillationBatch(input) {
   await writeJsonFile(paths2.batchPath, input.batch, { overwrite });
   const knowledgePaths = [];
   for (const record of input.batch.knowledgeRecords) {
-    const path = join15(paths2.knowledgeRecordsDir, `${record.id}.json`);
+    const path = join16(paths2.knowledgeRecordsDir, `${record.id}.json`);
     await writeJsonFile(path, record, { overwrite });
     knowledgePaths.push(path);
   }
   const evosCasePaths = [];
   for (const evosCase of input.batch.evosCases) {
-    const path = join15(paths2.evosCasesProjectDir, `${evosCase.id}.json`);
+    const path = join16(paths2.evosCasesProjectDir, `${evosCase.id}.json`);
     await writeJsonFile(path, evosCase, { overwrite });
     evosCasePaths.push(path);
   }
   const repoProposalPaths = [];
   for (const proposal of input.batch.repoProposals) {
-    const path = join15(paths2.repoProposalsDir, `${proposal.id}.json`);
+    const path = join16(paths2.repoProposalsDir, `${proposal.id}.json`);
     await writeJsonFile(path, proposal, { overwrite });
     repoProposalPaths.push(path);
   }
@@ -11958,7 +12218,7 @@ async function writeEvolutionDistillationBatch(input) {
   const evosCasesRootDir = resolveEvoDevPaths(input.homeDir).evosCasesDir;
   const evosProjectKeys = await listDirectoryNames(evosCasesRootDir);
   const evosProjects = await Promise.all(evosProjectKeys.map(async (projectKey) => {
-    const cases = await readJsonFiles(join15(evosCasesRootDir, projectKey), parseEvosCase);
+    const cases = await readJsonFiles(join16(evosCasesRootDir, projectKey), parseEvosCase);
     return {
       projectKey,
       cases: cases.map((evosCase) => ({
@@ -11996,6 +12256,33 @@ async function writeEvolutionDistillationBatch(input) {
     evosIndexPath: paths2.evosIndexPath
   };
 }
+async function writeEvolutionRepoProposal(input) {
+  validateEvolutionRepoProposal(input.proposal);
+  if (!hasConcreteRepoProposalChanges(input.proposal)) {
+    throw new Error("Repo proposal must include a target repository and concrete file changes.");
+  }
+  const paths2 = resolveEvolutionPaths({
+    homeDir: input.homeDir,
+    projectKey: input.proposal.projectKey,
+    runId: input.proposal.provenance.runId
+  });
+  const proposalPath = join16(paths2.repoProposalsDir, `${input.proposal.id}.json`);
+  await writeJsonFile(proposalPath, input.proposal, { overwrite: false });
+  const allRunProposals = await readJsonFiles(paths2.repoProposalsDir, parseRepoProposal);
+  await writeJsonFile(paths2.repoProposalsIndexPath, {
+    schemaVersion: 1,
+    projectKey: input.proposal.projectKey,
+    runId: input.proposal.provenance.runId,
+    updatedAt: input.proposal.provenance.createdAt,
+    proposals: allRunProposals.map((proposal) => ({
+      id: proposal.id,
+      kind: proposal.kind,
+      title: proposal.title,
+      reviewState: proposal.reviewState
+    }))
+  }, { overwrite: true });
+  return { proposalPath, indexPath: paths2.repoProposalsIndexPath };
+}
 async function activateEvolutionDistillationBatch(input) {
   validateEvolutionDistillationBatch(input.batch);
   const paths2 = resolveEvolutionPaths({
@@ -12020,20 +12307,20 @@ async function activateEvolutionDistillationBatch(input) {
     const matchingCandidate = plan.candidates.find((candidate) => candidate.id === evosCase.id);
     const persistedEvosCase = matchingCandidate?.decision === "auto-accept" ? { ...evosCase, reviewState: "auto-accepted" } : matchingCandidate?.decision === "needs-human" ? { ...evosCase, reviewState: "needs-human" } : evosCase;
     validateEvolutionEvosCase(persistedEvosCase);
-    const path = join15(paths2.evosCasesProjectDir, `${evosCase.id}.json`);
+    const path = join16(paths2.evosCasesProjectDir, `${evosCase.id}.json`);
     await writeJsonFile(path, persistedEvosCase, { overwrite });
     evosCasePaths.push(path);
   }
   const repoProposalPaths = [];
   for (const proposal of input.batch.repoProposals) {
-    const path = join15(paths2.repoProposalsDir, `${proposal.id}.json`);
+    const path = join16(paths2.repoProposalsDir, `${proposal.id}.json`);
     await writeJsonFile(path, proposal, { overwrite });
     repoProposalPaths.push(path);
   }
   const evosCasesRootDir = resolveEvoDevPaths(input.homeDir).evosCasesDir;
   const evosProjectKeys = await listDirectoryNames(evosCasesRootDir);
   const evosProjects = await Promise.all(evosProjectKeys.map(async (projectKey) => {
-    const cases = await readJsonFiles(join15(evosCasesRootDir, projectKey), parseEvosCase);
+    const cases = await readJsonFiles(join16(evosCasesRootDir, projectKey), parseEvosCase);
     return {
       projectKey,
       cases: cases.map((evosCase) => ({
@@ -12089,8 +12376,8 @@ function createProvenance(evidenceWindow, createdAt, sourceRefs) {
   };
 }
 // packages/core/src/evolution/processor/process.ts
-import { mkdir as mkdir10, rm as rm2, stat as stat7, writeFile as writeFile9 } from "node:fs/promises";
-import { dirname as dirname10, join as join16 } from "node:path";
+import { mkdir as mkdir11, rm as rm3, stat as stat7, writeFile as writeFile10 } 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) {
   const now = normalizeTimestamp(input.now);
@@ -12153,16 +12440,11 @@ async function processEvolutionTriggers(input) {
         attempts: (current) => current.attempts + 1
       });
       try {
-        await writeSegmentReviewCandidate({
-          homeDir: input.homeDir,
-          trigger,
-          now
-        });
         result.consumed += 1;
         await updateSegmentTriggers(input.homeDir, [trigger], {
           status: "consumed",
           updatedAt: now,
-          processedBatchId: createStableId("segment-review", [trigger.id]),
+          processedBatchId: createStableId("segment-evidence", [trigger.id]),
           lastError: null
         });
       } catch (error) {
@@ -12254,10 +12536,10 @@ async function processEvolutionTriggers(input) {
 }
 async function acquireEvolutionProcessLock(homeDir, now) {
   const paths2 = resolveEvoDevPaths(homeDir);
-  const lockPath = join16(paths2.stateDir, "evolution", ".process.lock");
-  await mkdir10(dirname10(lockPath), { recursive: true });
+  const lockPath = join17(paths2.stateDir, "evolution", ".process.lock");
+  await mkdir11(dirname11(lockPath), { recursive: true });
   try {
-    await writeFile9(lockPath, `${JSON.stringify({
+    await writeFile10(lockPath, `${JSON.stringify({
       schemaVersion: 1,
       kind: "evolution-process-lock",
       createdAt: now,
@@ -12270,70 +12552,18 @@ async function acquireEvolutionProcessLock(homeDir, now) {
       throw error;
     const current = await stat7(lockPath).catch(() => null);
     if (current !== null && Date.now() - current.mtimeMs > PROCESS_LOCK_STALE_MS2) {
-      await rm2(lockPath, { force: true });
+      await rm3(lockPath, { force: true });
       return acquireEvolutionProcessLock(homeDir, now);
     }
     return null;
   }
 }
 async function releaseEvolutionProcessLock(lock) {
-  await rm2(lock.path, { force: true });
-}
-async function writeSegmentReviewCandidate(input) {
-  const runId = input.trigger.runId ?? `session-${input.trigger.sessionKey}`;
-  const paths2 = resolveEvolutionPaths({
-    homeDir: input.homeDir,
-    projectKey: input.trigger.projectKey,
-    runId
-  });
-  const candidate = {
-    schemaVersion: 1,
-    kind: "evolution-review-candidate",
-    id: createStableId("review", [input.trigger.id]),
-    projectKey: input.trigger.projectKey,
-    runId: paths2.runId,
-    createdAt: input.now,
-    candidateKind: "session-memory-segment",
-    title: sanitizeText(`Review session segment ${input.trigger.reason}`),
-    targetStore: "session-memory-segments",
-    targetPath: input.trigger.segmentPath,
-    stableKey: createStableId("segment-candidate", [
-      input.trigger.projectKey,
-      input.trigger.sessionKey,
-      input.trigger.segmentId
-    ]),
-    reviewState: "needs-human",
-    reasons: [input.trigger.reason, input.trigger.strength],
-    candidate: {
-      segmentId: input.trigger.segmentId,
-      sessionKey: input.trigger.sessionKey,
-      roleId: input.trigger.roleId,
-      summary: input.trigger.summary,
-      reviewAction: "Open the referenced local session segment for raw evidence before approving memory or OKF changes.",
-      directOkfWrite: false,
-      localOnly: true
-    },
-    provenance: {
-      runId: paths2.runId,
-      evidenceWindowId: input.trigger.segmentId,
-      evidenceRefs: [input.trigger.id, input.trigger.segmentId],
-      createdBy: "evodev",
-      rawLogsStored: false,
-      rawPromptsStored: false,
-      sourceDumpsStored: false,
-      rawCommandOutputStored: false
-    },
-    privacy: createPrivacyFields()
-  };
-  validateEvolutionReviewCandidate(candidate);
-  await writeJsonFile(join16(paths2.reviewCandidatesDir, `${candidate.id}.json`), candidate, {
-    overwrite: true
-  });
-  return candidate;
+  await rm3(lock.path, { force: true });
 }
 // packages/core/src/observability/index.ts
-import { mkdir as mkdir11, readFile as readFile15, readdir as readdir9, stat as stat8, writeFile as writeFile10 } from "node:fs/promises";
-import { dirname as dirname11, join as join17 } from "node:path";
+import { mkdir as mkdir12, readFile as readFile15, readdir as readdir10, stat as stat8, writeFile as writeFile11 } from "node:fs/promises";
+import { dirname as dirname12, join as join18 } from "node:path";
 var EVENT_TYPE_TO_DIR = {
   "verification.completed": "verification",
   "workflow.step.planned": "workflows",
@@ -12395,14 +12625,14 @@ function validateObservabilityEvent(event) {
   assertNoForbiddenContent(event);
 }
 function resolveObservabilityStorePaths(homeDir, type) {
-  const rootDir = join17(homeDir, ".evodev", "OBSERVABILITY", EVENT_TYPE_TO_DIR[type]);
-  return { rootDir, eventsPath: join17(rootDir, "events.jsonl") };
+  const rootDir = join18(homeDir, ".evodev", "OBSERVABILITY", EVENT_TYPE_TO_DIR[type]);
+  return { rootDir, eventsPath: join18(rootDir, "events.jsonl") };
 }
 async function appendObservabilityEvent(homeDir, event) {
   validateObservabilityEvent(event);
   const paths2 = resolveObservabilityStorePaths(homeDir, event.type);
-  await mkdir11(dirname11(paths2.eventsPath), { recursive: true });
-  await writeFile10(paths2.eventsPath, `${JSON.stringify(event)}
+  await mkdir12(dirname12(paths2.eventsPath), { recursive: true });
+  await writeFile11(paths2.eventsPath, `${JSON.stringify(event)}
 `, { encoding: "utf8", flag: "a" });
   return paths2.eventsPath;
 }
@@ -12424,7 +12654,7 @@ async function listObservabilityEvents(homeDir, type) {
   return events.sort((left, right) => left.timestamp.localeCompare(right.timestamp));
 }
 async function dryRunObservabilityRetentionCleanup(homeDir) {
-  const root = join17(homeDir, ".evodev", "OBSERVABILITY");
+  const root = join18(homeDir, ".evodev", "OBSERVABILITY");
   const candidates = [];
   if (!await pathExists6(root))
     return { candidates, totalBytes: 0 };
@@ -12495,10 +12725,10 @@ function assertNoForbiddenContent(value) {
   }
 }
 async function collectJsonlFiles(root) {
-  const entries = await readdir9(root, { withFileTypes: true });
+  const entries = await readdir10(root, { withFileTypes: true });
   const files = [];
   for (const entry of entries) {
-    const path = join17(root, entry.name);
+    const path = join18(root, entry.name);
     if (entry.isDirectory())
       files.push(...await collectJsonlFiles(path));
     if (entry.isFile() && entry.name.endsWith(".jsonl"))
@@ -12530,8 +12760,8 @@ function normalizeKey(key) {
 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;
 function resolveDaemonPaths(homeDir) {
-  const rootDir = join18(homeDir, ".evodev", "STATE", "daemon");
-  return { rootDir, lockPath: join18(rootDir, "lock.json"), tokenPath: join18(rootDir, "token") };
+  const rootDir = join19(homeDir, ".evodev", "STATE", "daemon");
+  return { rootDir, lockPath: join19(rootDir, "lock.json"), tokenPath: join19(rootDir, "token") };
 }
 function validateDaemonBindHost(host) {
   if (host === "127.0.0.1" || host === "localhost")
@@ -12571,14 +12801,14 @@ async function writeDaemonState(input) {
     tokenPath: plan.paths.tokenPath,
     versionText: input.versionText ?? "evodev 0.0.1-alpha"
   };
-  await mkdir12(dirname12(plan.paths.lockPath), { recursive: true });
-  await writeFile11(plan.paths.tokenPath, `${token}
+  await mkdir13(dirname13(plan.paths.lockPath), { recursive: true });
+  await writeFile12(plan.paths.tokenPath, `${token}
 `, {
     encoding: "utf8",
     flag: "wx",
     mode: 384
   });
-  await writeFile11(plan.paths.lockPath, `${JSON.stringify(lock, null, 2)}
+  await writeFile12(plan.paths.lockPath, `${JSON.stringify(lock, null, 2)}
 `, {
     encoding: "utf8",
     flag: "wx",
@@ -12609,8 +12839,8 @@ async function cleanupDaemonState(homeDir, token) {
   const lock = await readDaemonLock(homeDir);
   if (lock === null || lock.component !== "evodev-daemon")
     throw new Error("Missing valid daemon lock.");
-  await rm3(paths2.lockPath, { force: true });
-  await rm3(paths2.tokenPath, { force: true });
+  await rm4(paths2.lockPath, { force: true });
+  await rm4(paths2.tokenPath, { force: true });
   return [paths2.lockPath, paths2.tokenPath];
 }
 async function handleDaemonRequest(input) {
@@ -12668,9 +12898,9 @@ async function handleDaemonRequest(input) {
   if (input.path === "/memory/candidates")
     return ok(await collectLearningCandidateSummaries(input.homeDir, warnings), warnings);
   if (input.path === "/projects")
-    return ok(await collectDirectorySummaries(join18(input.homeDir, ".evodev", "PROJECTS"), warnings), warnings);
+    return ok(await collectDirectorySummaries(join19(input.homeDir, ".evodev", "PROJECTS"), warnings), warnings);
   if (input.path === "/packs")
-    return ok(await collectDirectorySummaries(join18(input.homeDir, ".evodev", "PACKS"), warnings), warnings);
+    return ok(await collectDirectorySummaries(join19(input.homeDir, ".evodev", "PACKS"), warnings), warnings);
   if (input.path === "/runs")
     return ok(await collectTeamRuns(input.homeDir, warnings), warnings);
   if (input.path === "/evolution/triggers")
@@ -12788,7 +13018,7 @@ function isAllowedLocalOrigin(origin) {
   }
 }
 async function collectTaskSummaries(homeDir, warnings) {
-  const root = join18(homeDir, ".evodev", "STATE", "tasks");
+  const root = join19(homeDir, ".evodev", "STATE", "tasks");
   if (!await pathExists7(root)) {
     warnings.push("Task store not found; returning empty tasks.");
     return [];
@@ -12826,7 +13056,7 @@ async function collectObservabilitySummaries(homeDir, warnings) {
   }
 }
 async function collectLearningCandidateSummaries(homeDir, warnings) {
-  const path = join18(homeDir, ".evodev", "STATE", "learning", "candidates.jsonl");
+  const path = join19(homeDir, ".evodev", "STATE", "learning", "candidates.jsonl");
   if (!await pathExists7(path)) {
     warnings.push("Learning candidate store not found; returning empty candidates.");
     return [];
@@ -13063,7 +13293,7 @@ async function collectDirectorySummaries(root, warnings) {
     warnings.push(`Store not found: ${root}`);
     return [];
   }
-  const entries = await readdir10(root, { withFileTypes: true });
+  const entries = await readdir11(root, { withFileTypes: true });
   return entries.filter((entry) => entry.isDirectory()).map((entry) => ({ id: entry.name, metadataOnly: true }));
 }
 function sanitizeMetadata(value) {
@@ -13114,13 +13344,13 @@ function optionalBodyBoolean(value) {
   return typeof value === "boolean" ? value : undefined;
 }
 function resolveDaemonEvolutionProcessErrorPath(homeDir) {
-  return join18(resolveDaemonPaths(homeDir).rootDir, "evolution-process-error.json");
+  return join19(resolveDaemonPaths(homeDir).rootDir, "evolution-process-error.json");
 }
 async function recordDaemonEvolutionProcessError(homeDir, error) {
   try {
     const path = resolveDaemonEvolutionProcessErrorPath(homeDir);
-    await mkdir12(dirname12(path), { recursive: true });
-    await writeFile11(path, `${JSON.stringify({
+    await mkdir13(dirname13(path), { recursive: true });
+    await writeFile12(path, `${JSON.stringify({
       schemaVersion: 1,
       kind: "daemon-evolution-process-error",
       updatedAt: new Date().toISOString(),
@@ -13130,7 +13360,7 @@ async function recordDaemonEvolutionProcessError(homeDir, error) {
   } catch {}
 }
 async function clearDaemonEvolutionProcessError(homeDir) {
-  await rm3(resolveDaemonEvolutionProcessErrorPath(homeDir), { force: true }).catch(() => {
+  await rm4(resolveDaemonEvolutionProcessErrorPath(homeDir), { force: true }).catch(() => {
     return;
   });
 }
@@ -13145,10 +13375,10 @@ function describeError3(error) {
   return error instanceof Error ? error.message : String(error);
 }
 async function collectNamedFiles(root, name) {
-  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);
+    const path = join19(root, entry.name);
     if (entry.isDirectory())
       files.push(...await collectNamedFiles(path, name));
     else if (entry.isFile() && entry.name === name)
@@ -13202,8 +13432,8 @@ __export(exports_review, {
   appendLearningReviewDecision: () => appendLearningReviewDecision,
   appendLearningCandidate: () => appendLearningCandidate
 });
-import { mkdir as mkdir13, readFile as readFile17, stat as stat10, writeFile as writeFile12 } from "node:fs/promises";
-import { dirname as dirname13, join as join19 } from "node:path";
+import { mkdir as mkdir14, readFile as readFile17, stat as stat10, writeFile as writeFile13 } from "node:fs/promises";
+import { dirname as dirname14, join as join20 } from "node:path";
 var LEARNING_CANDIDATE_KINDS = [
   "lesson",
   "anti-criteria",
@@ -13300,7 +13530,7 @@ function createLearningCandidate(input) {
   return candidate;
 }
 function validateLearningCandidate(candidate) {
-  if (!isRecord10(candidate))
+  if (!isRecord11(candidate))
     throw new Error("Learning candidate must be an object.");
   if (candidate.version !== 1)
     throw new Error("Learning candidate version must be 1.");
@@ -13312,33 +13542,33 @@ function validateLearningCandidate(candidate) {
   if (candidate.routingInfluence !== false) {
     throw new Error("Learning candidate routingInfluence must be false in I5.");
   }
-  if (!isRecord10(candidate.scope))
+  if (!isRecord11(candidate.scope))
     throw new Error("Learning candidate scope must be an object.");
   assertEnumValue("scope.level", candidate.scope.level, LEARNING_SCOPE_LEVELS);
-  if (!isRecord10(candidate.content)) {
+  if (!isRecord11(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 (!isRecord10(candidate.provenance)) {
+  if (!isRecord11(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 (!isRecord10(candidate.privacy)) {
+  if (!isRecord11(candidate.privacy)) {
     throw new Error("Learning candidate privacy must be an object.");
   }
   assertEnumValue("privacy.classification", candidate.privacy.classification, ["local-private"]);
-  if (!isRecord10(candidate.review))
+  if (!isRecord11(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 (!isRecord10(candidate.retention)) {
+  if (!isRecord11(candidate.retention)) {
     throw new Error("Learning candidate retention must be an object.");
   }
   assertEnumValue("confidence", candidate.confidence, LEARNING_CONFIDENCE_VALUES);
@@ -13354,7 +13584,7 @@ function validateLearningCandidate(candidate) {
   assertNoForbiddenContent2(candidate);
 }
 function validateLearningReviewDecisionRecord(record) {
-  if (!isRecord10(record))
+  if (!isRecord11(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.");
@@ -13377,13 +13607,13 @@ function validateLearningReviewDecisionRecord(record) {
   assertNoForbiddenContent2(record);
 }
 function parseLearningCandidate(value) {
-  if (!isRecord10(value))
+  if (!isRecord11(value))
     throw new Error("Invalid learning candidate JSON.");
   validateLearningCandidate(value);
   return value;
 }
 function parseLearningReviewDecisionRecord(value) {
-  if (!isRecord10(value))
+  if (!isRecord11(value))
     throw new Error("Invalid learning review decision JSON.");
   validateLearningReviewDecisionRecord(value);
   return value;
@@ -13395,16 +13625,16 @@ async function readLearningReviewDecisions(path) {
   return parseJsonOrJsonlFile(path, parseLearningReviewDecisionRecord);
 }
 function resolveLearningCandidateQueuePath(homeDir) {
-  return join19(homeDir, ".evodev", "STATE", "learning", "candidates.jsonl");
+  return join20(homeDir, ".evodev", "STATE", "learning", "candidates.jsonl");
 }
 function resolveLearningDecisionPath(homeDir) {
-  return join19(homeDir, ".evodev", "STATE", "learning", "review-decisions.jsonl");
+  return join20(homeDir, ".evodev", "STATE", "learning", "review-decisions.jsonl");
 }
 async function appendLearningCandidate(homeDir, candidate) {
   validateLearningCandidate(candidate);
   const path = resolveLearningCandidateQueuePath(homeDir);
-  await mkdir13(dirname13(path), { recursive: true });
-  await writeFile12(path, `${JSON.stringify(candidate)}
+  await mkdir14(dirname14(path), { recursive: true });
+  await writeFile13(path, `${JSON.stringify(candidate)}
 `, { encoding: "utf8", flag: "a" });
   return path;
 }
@@ -13476,7 +13706,7 @@ function lintLearningCandidates(candidates2, options = {}) {
       validateLearningReviewDecisionRecord(decision);
     } catch (error) {
       findings.push({
-        candidateId: isRecord10(decision) && typeof decision.candidateId === "string" ? decision.candidateId : "unknown",
+        candidateId: isRecord11(decision) && typeof decision.candidateId === "string" ? decision.candidateId : "unknown",
         severity: "error",
         field: "decision",
         message: error instanceof Error ? error.message : String(error)
@@ -13563,8 +13793,8 @@ function createLearningReviewDecisionRecord(input) {
 async function appendLearningReviewDecision(homeDir, record) {
   validateLearningReviewDecisionRecord(record);
   const path = resolveLearningDecisionPath(homeDir);
-  await mkdir13(dirname13(path), { recursive: true });
-  await writeFile12(path, `${JSON.stringify(record)}
+  await mkdir14(dirname14(path), { recursive: true });
+  await writeFile13(path, `${JSON.stringify(record)}
 `, { encoding: "utf8", flag: "a" });
   return path;
 }
@@ -13674,7 +13904,7 @@ function assertNoForbiddenContent2(value) {
       assertNoForbiddenContent2(item);
     return;
   }
-  if (!isRecord10(value))
+  if (!isRecord11(value))
     return;
   for (const [key, child] of Object.entries(value)) {
     const normalizedKey = normalizeKey2(key);
@@ -13700,12 +13930,12 @@ function sanitizeNullableId(value) {
 function normalizeKey2(key) {
   return key.toLowerCase().replace(/[^a-z0-9]/g, "");
 }
-function isRecord10(value) {
+function isRecord11(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 // packages/core/src/pack/index.ts
-import { readFile as readFile18, readdir as readdir11, stat as stat11 } from "node:fs/promises";
-import { isAbsolute as isAbsolute6, join as join20, relative as relative7, sep } from "node:path";
+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";
 
 // packages/core/src/protected-zones/index.ts
 var SENSITIVE_DIRECTORY_SEGMENTS = new Set([
@@ -13849,7 +14079,7 @@ async function validatePack(packPath) {
     throw new Error("Only local pack directories are supported in I6.");
   }
   const packRoot = await resolvePackRoot(packPath);
-  const manifestPath = join20(packRoot, MANIFEST_FILE_NAME);
+  const manifestPath = join21(packRoot, MANIFEST_FILE_NAME);
   const findings = [];
   let manifest;
   let assets = [];
@@ -13940,7 +14170,7 @@ async function planPackInstallDryRun(input) {
   };
 }
 function parsePackManifest(value) {
-  if (!isRecord11(value))
+  if (!isRecord12(value))
     throw new Error("Pack manifest must be an object.");
   const manifest = value;
   validateManifestTopLevelFields(manifest);
@@ -13995,7 +14225,7 @@ function parsePackManifest(value) {
       userPath: requireString(customizations, "userPath"),
       projectPath: requireString(customizations, "projectPath")
     },
-    protectedZones: isRecord11(manifest.protectedZones) ? {
+    protectedZones: isRecord12(manifest.protectedZones) ? {
       neverInclude: optionalStringArray(manifest.protectedZones, "neverInclude"),
       neverWrite: optionalStringArray(manifest.protectedZones, "neverWrite")
     } : undefined,
@@ -14103,7 +14333,7 @@ function manifestAssetRefs(manifest, packRoot, findings) {
         findings.push({ ...pathFinding, path: assetPath });
         continue;
       }
-      refs.push({ kind, path: assetPath, absolutePath: join20(packRoot, assetPath) });
+      refs.push({ kind, path: assetPath, absolutePath: join21(packRoot, assetPath) });
     }
   }
   return refs;
@@ -14185,10 +14415,10 @@ function validateGuideReferences(manifest, assets, findings) {
   }
 }
 async function collectPackRelativePaths(packRoot, dir = packRoot) {
-  const entries = await readdir11(dir, { withFileTypes: true });
+  const entries = await readdir12(dir, { withFileTypes: true });
   const paths3 = [];
   for (const entry of entries) {
-    const absolutePath = join20(dir, entry.name);
+    const absolutePath = join21(dir, entry.name);
     const relativePath = normalizeRelativePath(relative7(packRoot, absolutePath));
     paths3.push(relativePath);
     if (entry.isDirectory()) {
@@ -14219,7 +14449,7 @@ function validatePackRelativePath(path, packRoot) {
       message: "Path must not escape pack root."
     };
   }
-  const absolute = join20(packRoot, normalized);
+  const absolute = join21(packRoot, normalized);
   const rel = relative7(packRoot, absolute);
   if (rel === "" || rel.startsWith("..") || isAbsolute6(rel)) {
     return {
@@ -14266,7 +14496,7 @@ function parseAssets(value) {
 function parsePermissions(value) {
   if (value === undefined)
     return {};
-  if (!isRecord11(value))
+  if (!isRecord12(value))
     throw new Error("Pack manifest permissions must be an object.");
   const permissions = {};
   const knownKeys = new Set(Object.keys(RISKY_PERMISSION_LABELS));
@@ -14304,7 +14534,7 @@ function requireBoolean(record, key) {
 }
 function requireRecord(record, key) {
   const value = record[key];
-  if (!isRecord11(value))
+  if (!isRecord12(value))
     throw new Error(`Pack manifest missing object field: ${key}`);
   return value;
 }
@@ -14360,7 +14590,7 @@ function validateCompatibilityTargets(packId, targets) {
 function validateProtectedZoneDeclarations(value) {
   if (value === undefined)
     return;
-  if (!isRecord11(value))
+  if (!isRecord12(value))
     throw new Error("Pack manifest protectedZones must be an object.");
   const knownFields = new Set(["neverInclude", "neverWrite"]);
   for (const key of Object.keys(value)) {
@@ -14373,7 +14603,7 @@ function validateProtectedZoneDeclarations(value) {
 function isRemotePackInput(packPath) {
   return /^[a-z][a-z0-9+.-]*:\/\//i.test(packPath);
 }
-function isRecord11(value) {
+function isRecord12(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function normalizeRelativePath(path) {
@@ -14386,8 +14616,8 @@ function formatError(error) {
   return error instanceof Error ? error.message : String(error);
 }
 // packages/core/src/plugins/capabilities.ts
-import { mkdir as mkdir14, readFile as readFile19, writeFile as writeFile13 } from "node:fs/promises";
-import { dirname as dirname14, join as join21 } from "node:path";
+import { mkdir as mkdir15, readFile as readFile19, writeFile as writeFile14 } from "node:fs/promises";
+import { dirname as dirname15, join as join22 } from "node:path";
 function createUnknownNegotiatedCapabilities(pluginId) {
   return {
     pluginId,
@@ -14497,13 +14727,13 @@ async function createCodexCapabilityVerificationArtifact(input) {
   };
 }
 function resolveCodexCapabilityArtifactPath(homeDir) {
-  return join21(homeDir, ".evodev", "STATE", "plugins", "codex", "capability-verification.json");
+  return join22(homeDir, ".evodev", "STATE", "plugins", "codex", "capability-verification.json");
 }
 async function writeCodexCapabilityVerificationArtifact(homeDir, artifact) {
   validateCodexCapabilityVerificationArtifact(artifact);
   const path = resolveCodexCapabilityArtifactPath(homeDir);
-  await mkdir14(dirname14(path), { recursive: true });
-  await writeFile13(path, `${JSON.stringify(artifact, null, 2)}
+  await mkdir15(dirname15(path), { recursive: true });
+  await writeFile14(path, `${JSON.stringify(artifact, null, 2)}
 `, { encoding: "utf8", flag: "wx" });
   return path;
 }
@@ -14635,8 +14865,8 @@ 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 mkdir15, readFile as readFile20, readdir as readdir12, stat as stat12, writeFile as writeFile14 } from "node:fs/promises";
-import { basename as basename5, join as join22, relative as relative8 } from "node:path";
+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",
@@ -14735,7 +14965,7 @@ async function createProjectContextPlan(projectDir) {
     sourceContentIncluded: false
   };
   const planFiles = await Promise.all(PROJECT_CONTEXT_ALLOWED_RELATIVE_PATHS.map(async (relativePath) => {
-    const absolutePath = join22(projectDir, relativePath);
+    const absolutePath = join23(projectDir, relativePath);
     const exists = await pathExists9(absolutePath);
     return {
       relativePath,
@@ -14766,9 +14996,9 @@ ${plan.errors.join(`
   const writtenFiles = [];
   for (const relativePath of PROJECT_CONTEXT_ALLOWED_RELATIVE_PATHS) {
     const content = payloads[relativePath];
-    const absolutePath = join22(plan.projectDir, relativePath);
-    await mkdir15(join22(absolutePath, ".."), { recursive: true });
-    await writeFile14(absolutePath, content, { encoding: "utf8", flag: "wx" });
+    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 };
@@ -14840,9 +15070,9 @@ function createProfileMarkdown(plan) {
 async function collectProjectFileMetadata(projectDir) {
   const files = [];
   async function visit(dir) {
-    const entries = await readdir12(dir, { withFileTypes: true });
+    const entries = await readdir13(dir, { withFileTypes: true });
     for (const entry of entries) {
-      const absolutePath = join22(dir, entry.name);
+      const absolutePath = join23(dir, entry.name);
       const relativePath = relative8(projectDir, absolutePath).replaceAll("\\", "/");
       if (shouldExcludePath(relativePath, entry.isDirectory())) {
         continue;
@@ -14862,7 +15092,7 @@ async function collectProjectFileMetadata(projectDir) {
   return files.sort((left, right) => left.path.localeCompare(right.path));
 }
 async function collectProjectCommands(projectDir) {
-  const packageJsonPath = join22(projectDir, "package.json");
+  const packageJsonPath = join23(projectDir, "package.json");
   const warnings = [];
   if (!await pathExists9(packageJsonPath)) {
     return { version: 1, metadataOnly: true, rawCommandsIncluded: false, scripts: [], warnings };
@@ -14874,7 +15104,7 @@ async function collectProjectCommands(projectDir) {
     warnings.push(`package.json scripts skipped: ${describeError4(error)}`);
     return { version: 1, metadataOnly: true, rawCommandsIncluded: false, scripts: [], warnings };
   }
-  const scripts = isRecord12(parsed) && isRecord12(parsed.scripts) ? parsed.scripts : {};
+  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") {
@@ -14984,14 +15214,14 @@ async function pathExists9(path) {
     throw error;
   }
 }
-function isRecord12(value) {
+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 join23 } from "node:path";
+import { join as join24 } from "node:path";
 async function runSync(options) {
   const store = createCoreConfigStore(options.homeDir);
   const settings = await store.readSettings();
@@ -15134,8 +15364,8 @@ function filterAssetsForTarget(assets, targetPlugin) {
 }
 function resolveAssetScannerPaths(assetsRootDir) {
   return {
-    skillsDir: join23(assetsRootDir, "skills"),
-    agentsDir: join23(assetsRootDir, "agents")
+    skillsDir: join24(assetsRootDir, "skills"),
+    agentsDir: join24(assetsRootDir, "agents")
   };
 }
 async function readRegistryOrDefault(store) {
@@ -15363,7 +15593,7 @@ async function runTeamsMcpStdioServer(options = {}) {
   }
 }
 function initializeResult(request) {
-  const params = isRecord13(request.params) ? request.params : {};
+  const params = isRecord14(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 {
@@ -15445,7 +15675,7 @@ function toolResult(structuredContent, isError = false) {
   };
 }
 function parseRequest(message) {
-  if (!isRecord13(message))
+  if (!isRecord14(message))
     throw new Error("Invalid JSON-RPC message; expected object.");
   if (message.jsonrpc !== "2.0")
     throw new Error("Invalid JSON-RPC version.");
@@ -15472,7 +15702,7 @@ function jsonRpcError(id, code, message, data) {
   return { jsonrpc: "2.0", id, error: { code, message, data } };
 }
 function expectRecord5(value, path) {
-  if (!isRecord13(value))
+  if (!isRecord14(value))
     throw new Error(`Invalid ${path}; expected object.`);
   return value;
 }
@@ -15485,28 +15715,28 @@ function expectString3(value, path) {
 function optionalString7(value) {
   return typeof value === "string" && value.length > 0 ? value : undefined;
 }
-function isRecord13(value) {
+function isRecord14(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function describeError5(error) {
   return error instanceof Error ? error.message : String(error);
 }
 // packages/core/src/workflow/index.ts
-import { readFile as readFile21, readdir as readdir13 } from "node:fs/promises";
-import { join as join24 } from "node:path";
+import { readFile as readFile21, readdir as readdir14 } from "node:fs/promises";
+import { join as join25 } from "node:path";
 async function scanWorkflowManifests(workflowsDir) {
   const manifests = [];
-  const entries = await readdir13(workflowsDir, { withFileTypes: true });
+  const entries = await readdir14(workflowsDir, { withFileTypes: true });
   for (const entry of entries) {
     if (!entry.isDirectory())
       continue;
-    const manifestPath = join24(workflowsDir, entry.name, "WORKFLOW.json");
+    const manifestPath = join25(workflowsDir, entry.name, "WORKFLOW.json");
     manifests.push(parseWorkflowManifest(JSON.parse(await readFile21(manifestPath, "utf8"))));
   }
   return manifests.sort((left, right) => left.id.localeCompare(right.id));
 }
 function parseWorkflowManifest(value) {
-  if (!isRecord14(value))
+  if (!isRecord15(value))
     throw new Error("Workflow manifest must be an object.");
   const manifest = value;
   if (typeof manifest.id !== "string" || typeof manifest.version !== "string") {
@@ -15563,24 +15793,29 @@ function formatWorkflowPlan(plan) {
   ].join(`
 `);
 }
-function isRecord14(value) {
+function isRecord15(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 export {
   writeTaskContract,
+  writeSessionIndex,
   writeProjectContext,
+  writeJson2 as writeJson,
   writeFailedOkfKnowledgePlanArtifact,
+  writeEvolutionRepoProposal,
   writeEvolutionDistillationBatch,
   writeDaemonState,
   writeContextInjectionReceipt,
   writeCodexCapabilityVerificationArtifact,
   writeCodeAgentTraceRef,
+  withEvolutionReviewDecisionLock,
   verifyTaskContract,
   validatePack,
   validateOkfKnowledgePlanContract,
   validateObservabilityEvent,
   validateLearningReviewDecisionRecord,
   validateLearningCandidate,
+  validateEvolutionRepoProposal,
   validateEvolutionKnowledgeRecord,
   validateEvolutionEvidenceWindow,
   validateEvolutionDistillationBatch,
@@ -15591,6 +15826,7 @@ export {
   updateTeamAgentHookState,
   updateSessionMemoryFromHook,
   updateSegmentTriggers,
+  updateEvolutionRepoProposalReviewState,
   updateEvolutionKnowledgeReviewState,
   unsetTeamRoleBinding,
   supersedeOkfKnowledgeConcept,
@@ -15607,6 +15843,7 @@ export {
   scanSkillAssets,
   scanAssets,
   scanAgentAssets,
+  sanitizeProposedChange,
   runTeamsMcpStdioServer,
   runSync,
   runPluginConformance,
@@ -15647,14 +15884,19 @@ export {
   readTeamAgentSummary,
   readTeamAgentDefinition,
   readTaskContract,
+  readSessionState,
+  readSessionEvidenceSegment,
+  readSessionCursor,
   readRuntimeInjectionSettings,
   readPendingTeamMessagesForRole,
   readOkfKnowledgeConcept,
+  readLineRange,
   readLearningReviewDecisions,
   readLearningCandidates,
   readFailedOkfKnowledgePlanArtifact,
   readFailedOkfKnowledgePlan,
   readEvolutionReviewSnapshot,
+  readEvolutionRepoProposalById,
   readEvolutionKnowledgeRecordById,
   readDaemonToken,
   readDaemonLock,
@@ -15700,12 +15942,14 @@ export {
   listTeamRuns,
   listTeamRoleBindings,
   listTeamAgents,
+  listSessionEvidenceSegments,
   listSegmentEvolutionTriggers,
   listOkfKnowledgeConcepts,
   listObservabilityEvents,
   listLearningReviewDecisions,
   listLearningCandidates,
   listEvolutionTriggers,
+  listEvolutionKnowledgeReviewHistory,
   listEvolutionKnowledgeRecords,
   listEvolutionEvosCases,
   listCodeAgentTraceRefs,
@@ -15717,6 +15961,7 @@ export {
   isActiveTeamAgentStatus,
   initializeCoreConfig,
   hasContextInjectionReceipt,
+  hasConcreteRepoProposalChanges,
   handleTeamsMcpMessage,
   handleTeamsMcpLine,
   handleHookRuntime,
@@ -15784,6 +16029,7 @@ export {
   createLexicalKnowledgeDocumentFromEvosCase,
   createLearningReviewDecisionRecord,
   createLearningCandidate,
+  createEvolutionRepoProposal,
   createEvolutionDistillationBatch,
   createEvoDevExecutionEvent,
   createDefaultTeamRuntimeSettings,
@@ -15810,6 +16056,7 @@ export {
   assertOkfKnowledgePlanContract,
   applyStrictestAgentPermissions,
   appendTraceLogEntry,
+  appendRawEvent,
   appendObservabilityEvent,
   appendLearningReviewDecision,
   appendLearningCandidate,
@@ -15822,6 +16069,7 @@ export {
   TmuxRuntimeAdapter,
   TeamMessageBroker,
   TEAM_INTERNAL_WAKE_SIGNAL,
+  SessionMemoryEvidenceError,
   PluginRegistryError,
   PluginRegistry,
   PROJECT_CONTEXT_ALLOWED_RELATIVE_PATHS,