@rhei-team/rhei 1.0.0-beta.0 → 1.0.0-beta.1

package/dist/index.js

@@ -30320,8 +30320,9 @@ async function buildLocalCodeContextForGoalSnapshot(args) {
   const backendIntelligenceExactRefsForSelection = routeSlotContextGoal ? [] : backendIntelligenceExactRefs;
   const evidenceInputPresent = Boolean(args.evidenceIntake?.length || args.refinementEvidence?.length || args.diagnosticEvidence?.length);
   const goalExactRefsForSelection = evidenceInputPresent ? [] : goalExactRefs;
-  const exactRefs = uniqueStrings16([...explicitExactRefs, ...recentTouchedRefs, ...goalScopeFileRefs, ...explicitScopeFileRefs, ...goalExactRefsForSelection, ...boringMcpExactRefs, ...backendIntelligenceExactRefsForSelection]);
-  const collectionExactRefs = uniqueStrings16([...exactRefs, ...goalExactRefs, ...boringMcpEvidenceRefs, ...backendIntelligenceExactRefs, ...backendIntelligenceEvidenceRefs, ...categoryCollectionRefs]);
+  const goalScopeFileRefsForSelection = evidenceInputPresent ? [] : goalScopeFileRefs;
+  const exactRefs = uniqueStrings16([...explicitExactRefs, ...recentTouchedRefs, ...goalScopeFileRefsForSelection, ...explicitScopeFileRefs, ...goalExactRefsForSelection, ...boringMcpExactRefs, ...backendIntelligenceExactRefsForSelection]);
+  const collectionExactRefs = uniqueStrings16([...exactRefs, ...goalScopeFileRefs, ...goalExactRefs, ...boringMcpEvidenceRefs, ...backendIntelligenceExactRefs, ...backendIntelligenceEvidenceRefs, ...categoryCollectionRefs]);
   const maxFilesToScan = positiveInteger5(args.maxFilesToScan, DEFAULT_MAX_FILES_TO_SCAN);
   const collectStartedAt = Date.now();
   let collected = await collectCandidates(repoPath, terms, maxFilesToScan, core, { ...args, exactRefs: collectionExactRefs, allowEvalReportEvidenceRefs });
@@ -42985,10 +42986,20 @@ var rheiStatusToolOutputSchema = toolOutputSchema({
 var rheiLedgerToolInputSchema = toolObjectSchema({
   op: {
     type: "string",
-    enum: ["overview", "report_cards", "trust_diff", "explain_line"],
-    description: "Ledger projection. Defaults to overview."
+    enum: [
+      "overview",
+      "report_cards",
+      "trust_diff",
+      "explain_line",
+      "why_symbol_changed",
+      "what_changed_since"
+    ],
+    description: "Ledger projection. Defaults to overview. why_symbol_changed needs `symbol`; what_changed_since needs `sinceMs` or `sinceRef`."
   },
-  repoPath: STRING_SCHEMA
+  repoPath: STRING_SCHEMA,
+  symbol: { type: "string", description: "why_symbol_changed: symbol name or qualified name." },
+  sinceMs: { type: "number", description: "what_changed_since: inclusive lower bound (epoch ms)." },
+  sinceRef: { type: "string", description: "what_changed_since: git ref (e.g. HEAD~1, main) resolved to its commit time." }
 }, { additionalProperties: true });
 var rheiLedgerToolOutputSchema = toolOutputSchema({
   kind: STRING_SCHEMA,
@@ -42999,6 +43010,8 @@ var rheiLedgerToolOutputSchema = toolOutputSchema({
   reportCards: OBJECT_ARRAY_SCHEMA,
   trustDiff: OBJECT_SCHEMA,
   line: STRING_SCHEMA,
+  whySymbolChanged: OBJECT_SCHEMA,
+  whatChangedSince: OBJECT_SCHEMA,
   reportOnly: BOOLEAN_SCHEMA,
   advisoryOnly: BOOLEAN_SCHEMA,
   noAuthority: BOOLEAN_SCHEMA,
@@ -44262,7 +44275,7 @@ function briefRheiCodeIoHits(search) {
     return;
   const sqlSymbolSearch = search["searchMode"] === "sql_symbol_index" || search["searchTargetMode"] === "symbol_path";
   const results = codeIoRecordList(search["results"]).slice(0, 5).map((result) => {
-    const matchedLines = arrayValue4(result["matchedLines"]).map((line) => asRecord8(line)).filter((line) => Boolean(line)).slice(0, 4).map((line) => removeUndefined13({
+    const matchedLines = arrayValue4(result["matchedLines"]).map((line) => asRecord8(line)).filter((line) => Boolean(line)).slice(0, 1).map((line) => removeUndefined13({
       line: line["line"],
       preview: line["preview"]
     }));
@@ -45727,6 +45740,9 @@ function repoPromptSearchDto(search) {
   const omittedTotal = codeIoNonNegativeNumber(search["omittedResultCount"] ?? coverage?.["matchedRefsOmitted"]) ?? (omittedByResultLimit > 0 ? omittedByResultLimit : undefined);
   const omittedContentMatches = returnedMatchCount === undefined ? undefined : Math.max(0, totalMatchCount - returnedMatchCount);
   const sizeLimitHit = coverage?.["truncated"] === true;
+  const carriesNonRedundantInfo = omittedTotal !== undefined && omittedTotal > 0 || omittedContentMatches !== undefined && omittedContentMatches > 0 || sizeLimitHit || Boolean(cleanString23(scopeDiagnostic?.["summary"])) || Boolean(cleanString23(scopeDiagnostic?.["suggestion"])) || arrayValue4(search["warnings"]).length > 0 || perFileTotals.length > 0 || pathMatchLines.length > 0;
+  if (!carriesNonRedundantInfo)
+    return;
   return removeUndefined13({
     total_matches: totalMatchCount,
     total_files: codeIoNonNegativeNumber(coverage?.["searchedFiles"]) ?? resultCount,
@@ -46572,7 +46588,7 @@ function briefRheiCodeIoInspect(inspectResult) {
   const factCounts = asRecord8(codeStructureCoverage?.["factCounts"]);
   const emittedFactCounts = asRecord8(codeStructureCoverage?.["emittedFactCounts"]);
   const fullSymbolCount = positiveNumber12(factCounts?.["symbols"]) ?? symbols.length;
-  const emittedSymbolCount = positiveNumber12(emittedFactCounts?.["symbols"]) ?? symbols.length;
+  const emittedSymbolCount = positiveNumber12(emittedFactCounts?.["symbols"]);
   const nextReadPlan = arrayValue4(inspectResult["nextReadPlan"]);
   const codeStructureDiagnostic = asRecord8(inspect["codeStructureDiagnostic"]) ?? asRecord8(inspectResult["codeStructureDiagnostic"]);
   const imports = [];
@@ -46611,9 +46627,8 @@ function briefRheiCodeIoInspect(inspectResult) {
     mode: inspect["mode"],
     codemapProfile: inspect["codemapProfile"],
     fileCount: files.length,
-    symbolCount: symbols.length,
-    totalSymbolCount: fullSymbolCount !== symbols.length ? fullSymbolCount : undefined,
-    emittedSymbolCount: emittedSymbolCount !== symbols.length && emittedSymbolCount !== fullSymbolCount ? emittedSymbolCount : undefined,
+    symbolCount: fullSymbolCount,
+    emittedSymbolCount: emittedSymbolCount !== undefined && emittedSymbolCount !== fullSymbolCount ? emittedSymbolCount : undefined,
     importCount: imports.length,
     functionSignatureCount: functionSignatures.length,
     codeStructureContent,
@@ -48946,10 +48961,10 @@ function compactObservability(observability) {
     categoryCollectionRefCount: observability["categoryCollectionRefCount"]
   });
 }
-function compactContextReadPlanItem(value) {
+function compactContextReadPlanItem(value, includeContent = true) {
   if (!value)
     return;
-  const content = cleanString23(value["content"]);
+  const content = includeContent ? cleanString23(value["content"]) : undefined;
   return removeUndefined13({
     readId: value["readId"],
     path: value["path"],
@@ -49055,7 +49070,7 @@ function compactContextForGoalRead(value) {
   const maxContentChars = 12000;
   const readItems = arrayValue4(read["reads"]).map((item) => asRecord8(item)).filter((item) => Boolean(item));
   const singleRead = readItems.length === 0 && (cleanString23(read["path"]) || cleanString23(read["content"])) ? [read] : [];
-  const readPlan = arrayValue4(read["readPlan"]).slice(0, 12).map((item) => compactContextReadPlanItem(asRecord8(item))).filter((item) => Boolean(item));
+  const readPlan = arrayValue4(read["readPlan"]).slice(0, 12).map((item) => compactContextReadPlanItem(asRecord8(item), false)).filter((item) => Boolean(item));
   const compactReads = [...readItems, ...singleRead].slice(0, 12).map((item) => compactContextReadPlanItem(asRecord8(item))).filter((item) => Boolean(item));
   const paths = read["paths"] ?? singleRead.map((item) => item["path"]);
   const compactRead = removeUndefined13({
@@ -62181,13 +62196,19 @@ async function resolveMultiEditFrontier(input) {
   if (proposedPaths.length === 0)
     return unavailable("no_proposed_paths");
   const advisoryDepth = Math.min(activation2.effectiveDepth, 3);
+  const runAdvisory = input.includeAdvisory ?? true;
   let gateResult;
   let advisoryResult;
   try {
-    [gateResult, advisoryResult] = await Promise.all([
-      runQuery({ repoPath: input.repoPath, op: "impact", changedPaths: proposedPaths, depth: 1, artifactRoot: input.artifactRoot, env }),
-      runQuery({ repoPath: input.repoPath, op: "impact", changedPaths: proposedPaths, depth: advisoryDepth, artifactRoot: input.artifactRoot, env })
-    ]);
+    if (runAdvisory) {
+      [gateResult, advisoryResult] = await Promise.all([
+        runQuery({ repoPath: input.repoPath, op: "impact", changedPaths: proposedPaths, depth: 1, artifactRoot: input.artifactRoot, env }),
+        runQuery({ repoPath: input.repoPath, op: "impact", changedPaths: proposedPaths, depth: advisoryDepth, artifactRoot: input.artifactRoot, env })
+      ]);
+    } else {
+      gateResult = await runQuery({ repoPath: input.repoPath, op: "impact", changedPaths: proposedPaths, depth: 1, artifactRoot: input.artifactRoot, env });
+      advisoryResult = undefined;
+    }
   } catch (error) {
     return unavailable(`graph_query_threw: ${String(error).slice(0, 200)}`);
   }
@@ -62288,7 +62309,8 @@ async function goalStartReadPlanWithFrontier(contextForGoal, options = {}) {
     return { ...plan, frontier: { status: verdict.status, reason: verdict.reason } };
   }
   const planPaths = new Set(items.map((item) => cleanString23(item["path"])).filter(Boolean));
-  const addedPaths = uniqueStrings24([...verdict.gateEdges, ...verdict.advisoryFrontier]).filter((path) => !planPaths.has(path)).slice(0, 4);
+  const frontierPaths = uniqueStrings24([...verdict.gateEdges, ...verdict.advisoryFrontier]);
+  const addedPaths = frontierPaths.filter((path) => !planPaths.has(path)).slice(0, 4);
   const frontierItems = addedPaths.map((path, index) => ({
     order: items.length + index + 1,
     path,
@@ -62301,9 +62323,9 @@ async function goalStartReadPlanWithFrontier(contextForGoal, options = {}) {
     coverage: { ...asRecord8(plan["coverage"]) ?? {}, frontier: frontierItems.length },
     frontier: {
       status: verdict.status,
-      gateEdges: verdict.gateEdges.slice(0, 12),
-      advisoryFrontier: verdict.advisoryFrontier.slice(0, 12),
-      addedPaths
+      addedPaths,
+      gateEdgeCount: verdict.gateEdges.length,
+      frontierPathCount: frontierPaths.length
     }
   };
 }
@@ -62868,6 +62890,7 @@ async function buildWritebackGraduation(input) {
     repoPath,
     proposedPaths: changedPaths,
     gateEligible: true,
+    includeAdvisory: false,
     runQuery: input.runQuery
   });
   const verdictRecorded = input.synapseVerdictReceipt?.["status"] === "recorded";
@@ -66984,6 +67007,64 @@ function directCodeIoDeleteFile(args) {
   });
 }
 
+// src/codeContextTools/inverseCapture.ts
+import { deriveInverseEdit } from "./vendor/rhei-core/changeEpisode.js";
+function str2(value) {
+  return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function firstString2(record, keys) {
+  for (const key of keys) {
+    const value = str2(record[key]);
+    if (value !== undefined)
+      return value;
+  }
+  return;
+}
+var SEARCH_KEYS = ["search", "find", "old_string", "oldString", "oldText"];
+var REPLACE_KEYS = ["replace", "replacement", "with", "new_string", "newString", "newText"];
+function inverseEditsForFile(file) {
+  const path = str2(file["path"]);
+  if (!path)
+    return [];
+  const isDelete = file["delete"] === true || file["mode"] === "delete";
+  if (isDelete)
+    return [deriveInverseEdit({ kind: "delete", path })];
+  if (file["create"] === true)
+    return [deriveInverseEdit({ kind: "create", path })];
+  const rewrite = str2(file["rewrite"]) ?? str2(file["content"]);
+  if (rewrite !== undefined)
+    return [deriveInverseEdit({ kind: "rewrite", path, afterContent: rewrite })];
+  const edits = Array.isArray(file["edits"]) ? file["edits"] : [];
+  const inverses = [];
+  for (const raw of edits) {
+    if (typeof raw !== "object" || raw === null)
+      continue;
+    const edit = raw;
+    const search = firstString2(edit, SEARCH_KEYS);
+    const replace = firstString2(edit, REPLACE_KEYS);
+    if (search === undefined || replace === undefined)
+      continue;
+    inverses.push(deriveInverseEdit({ kind: "search_replace", path, search, replace }));
+  }
+  return inverses;
+}
+function inverseEditsForFiles(files) {
+  if (!Array.isArray(files))
+    return [];
+  const bundles = [];
+  for (const file of files) {
+    if (typeof file !== "object" || file === null)
+      continue;
+    const path = str2(file["path"]);
+    if (!path)
+      continue;
+    const inverse = inverseEditsForFile(file);
+    if (inverse.length > 0)
+      bundles.push({ path, inverse });
+  }
+  return bundles;
+}
+
 // src/codeContextTools/codeIoToolRuntimeAndServiceIntelligence.ts
 var RECENT_SEARCH_TRIAL_TTL_MS = 10 * 60 * 1000;
 var recentSearchTrials = new Map;
@@ -67804,12 +67885,18 @@ function codeIoRuntimeRestartInfo() {
     restartAction: asRecord8(runtime["restartAction"])
   };
 }
-function codeIoRuntimeWriteBlockRequired(op, _reloadStatus) {
-  return op === "edit" || op === "publish" || op === "revert";
+function codeIoRuntimeWriteBlockRequired(op, reloadStatus, targetPaths = []) {
+  if (op !== "edit" && op !== "publish" && op !== "revert")
+    return false;
+  if (reloadStatus["editEngineStale"] === true)
+    return true;
+  if (targetPaths.length === 0)
+    return true;
+  return targetPaths.some((path) => /(?:^|\/)packages\/mcp-server\/src\//.test(path));
 }
 function codeIoRuntimeFreshnessAdvisory(op, targetPaths = []) {
   const restartInfo = codeIoRuntimeRestartInfo();
-  if (!restartInfo || codeIoRuntimeWriteBlockRequired(op, restartInfo.reloadStatus))
+  if (!restartInfo || codeIoRuntimeWriteBlockRequired(op, restartInfo.reloadStatus, targetPaths))
     return;
   return removeUndefined13({
     kind: "rhei_code_io_runtime_freshness",
@@ -67861,7 +67948,7 @@ function codeIoRuntimeStaleWriteBlock(op, targetPaths = []) {
   const restartInfo = codeIoRuntimeRestartInfo();
   if (!restartInfo)
     return;
-  if (!codeIoRuntimeWriteBlockRequired(op, restartInfo.reloadStatus))
+  if (!codeIoRuntimeWriteBlockRequired(op, restartInfo.reloadStatus, targetPaths))
     return;
   return removeUndefined13({
     kind: op === "publish" || op === "revert" ? "rhei_code_git_publish" : "rhei_code_edit",
@@ -68657,6 +68744,7 @@ async function recordCodeIoEditProvenance(args, edit, files, dirtyEventReceipt)
       goal: cleanString23(args["goal"]) ?? cleanString23(args["message"]),
       createdAt
     })}`;
+    const inverseByPath = new Map(inverseEditsForFiles(files).map((bundle) => [bundle.path, bundle.inverse]));
     await getLedgerSink({ repoPath }).recordEditProvenance(buildEditProvenanceV1({
       provenanceId,
       source: "codex_mcp",
@@ -68669,7 +68757,11 @@ async function recordCodeIoEditProvenance(args, edit, files, dirtyEventReceipt)
       repoEpoch: cleanString23(asRecord8(edit["receipt"])?.["repoEpoch"]) ?? "repo_epoch_unknown_v1",
       scopePolicyHash: cleanString23(edit["scopePolicyHash"]) ?? UNKNOWN_SCOPE_POLICY_HASH,
       files: changedPaths,
-      hunks: changedPaths.map((path) => ({ filePath: path, startLine: 0, endLine: 0, kind: codeIoEditHunkKind(args) })),
+      hunks: changedPaths.map((path) => {
+        const inverse = inverseByPath.get(path);
+        const hunk = { filePath: path, startLine: 0, endLine: 0, kind: codeIoEditHunkKind(args) };
+        return inverse === undefined ? hunk : { ...hunk, inverse };
+      }),
       symbols: codeIoTouchedSymbols(files, edit),
       mcpReceipts: receiptRefs,
       nonMcpCommands: [],
@@ -69259,6 +69351,8 @@ async function buildRheiCodeIoPayload(args) {
     const postEditIndexWarmup = codeIoPostEditIndexWarmupReceipt(args, edit, files, dirtyEventReceipt);
     const frontierGateForResponse = frontierGate ? removeUndefined13({
       ...frontierGate,
+      advisoryFrontier: undefined,
+      advisoryFrontierCount: frontierGate.advisoryFrontier.length,
       evidence: undefined,
       evidenceSummary: frontierGate.evidence ? removeUndefined13({
         sourceEpochHash: frontierGate.evidence.sourceEpochHash,
@@ -70252,8 +70346,6 @@ var RHEI_MCP_PUBLIC_LOCAL_TOOL_NAMES = [
   "index",
   "status",
   "ledger",
-  "agent_run",
-  "agent_manage",
   "oracle_send",
   "oracle_utils"
 ];
@@ -73226,8 +73318,18 @@ var rheiStatusOutputSchema = z3.object({
   productionAuthority: z3.literal(false).optional()
 }).passthrough();
 var rheiLedgerInputSchema = z3.object({
-  op: z3.enum(["overview", "report_cards", "trust_diff", "explain_line"]).optional(),
-  repoPath: z3.string().min(1).optional()
+  op: z3.enum([
+    "overview",
+    "report_cards",
+    "trust_diff",
+    "explain_line",
+    "why_symbol_changed",
+    "what_changed_since"
+  ]).optional(),
+  repoPath: z3.string().min(1).optional(),
+  symbol: z3.string().optional(),
+  sinceMs: z3.number().optional(),
+  sinceRef: z3.string().optional()
 }).passthrough();
 var rheiLedgerOutputSchema = z3.object({
   kind: z3.string().optional(),
@@ -76775,31 +76877,31 @@ async function emitGoalMemoryCandidates(syncConfig, args) {
   const raw = args.structured["memoryCandidates"];
   if (!Array.isArray(raw) || raw.length === 0)
     return;
-  const str2 = (value) => typeof value === "string" && value.trim() ? value.trim() : undefined;
+  const str3 = (value) => typeof value === "string" && value.trim() ? value.trim() : undefined;
   const strArray = (value) => Array.isArray(value) ? value.filter((v) => typeof v === "string") : undefined;
-  const topGoal = str2(args.structured["goal"]);
-  const topSession = str2(args.structured["goalSessionId"]) ?? str2(args.structured["activeGoalId"]);
+  const topGoal = str3(args.structured["goal"]);
+  const topSession = str3(args.structured["goalSessionId"]) ?? str3(args.structured["activeGoalId"]);
   for (const entry of raw.slice(0, 20)) {
     if (!entry || typeof entry !== "object")
       continue;
     const candidate = entry;
-    const title = str2(candidate["title"]) ?? str2(candidate["summary"]);
-    const summary = str2(candidate["summary"]) ?? str2(candidate["title"]);
+    const title = str3(candidate["title"]) ?? str3(candidate["summary"]);
+    const summary = str3(candidate["summary"]) ?? str3(candidate["title"]);
     if (!title || !summary)
       continue;
     try {
       await postRetryableRheiSyncReceipt(syncConfig, "/v1/mcp/sync/goal-memory", {
         projectId: args.projectId,
         repoId: args.repoId,
-        sourceKind: str2(candidate["sourceKind"]) ?? "goal_finish",
-        candidateKind: str2(candidate["candidateKind"]) ?? "goal_session_learning",
+        sourceKind: str3(candidate["sourceKind"]) ?? "goal_finish",
+        candidateKind: str3(candidate["candidateKind"]) ?? "goal_session_learning",
         title,
         summary,
-        subjectKind: ["path", "symbol", "service"].includes(String(candidate["subjectKind"])) ? str2(candidate["subjectKind"]) : undefined,
-        subjectRef: str2(candidate["subjectRef"]),
-        normalizedRule: str2(candidate["normalizedRule"]) ?? str2(candidate["rule"]),
-        goal: str2(candidate["goal"]) ?? topGoal,
-        goalSessionId: str2(candidate["goalSessionId"]) ?? topSession,
+        subjectKind: ["path", "symbol", "service"].includes(String(candidate["subjectKind"])) ? str3(candidate["subjectKind"]) : undefined,
+        subjectRef: str3(candidate["subjectRef"]),
+        normalizedRule: str3(candidate["normalizedRule"]) ?? str3(candidate["rule"]),
+        goal: str3(candidate["goal"]) ?? topGoal,
+        goalSessionId: str3(candidate["goalSessionId"]) ?? topSession,
         filePaths: strArray(candidate["filePaths"]) ?? strArray(candidate["files"]),
         targetRefs: strArray(candidate["targetRefs"]),
         evidenceRefs: strArray(candidate["evidenceRefs"])
@@ -79497,14 +79599,14 @@ async function readFocusLedger(repoPath) {
     const raw = JSON.parse(await readFile22(path, "utf8"));
     const items = asArray(raw.items).flatMap((item) => {
       const record = asRecord11(item);
-      const stableKey = str2(record?.["stableKey"]);
-      const source = str2(record?.["source"]);
+      const stableKey = str3(record?.["stableKey"]);
+      const source = str3(record?.["source"]);
       if (!stableKey || !source)
         return [];
       return [{
         stableKey,
         source,
-        goalId: str2(record?.["goalId"]),
+        goalId: str3(record?.["goalId"]),
         showCount: num(record?.["showCount"]) ?? 0,
         lastShownAt: num(record?.["lastShownAt"]),
         snoozedUntil: num(record?.["snoozedUntil"]),
@@ -79792,7 +79894,7 @@ function extractReuse(report) {
       continue;
     const evidence2 = asRecord11(record["evidence"]);
     const dup = asRecord11(evidence2?.["duplicateEvidence"]);
-    const subtype = str2(dup?.["reuseSubtype"]) ?? str2(record["candidateKind"]) ?? "other";
+    const subtype = str3(dup?.["reuseSubtype"]) ?? str3(record["candidateKind"]) ?? "other";
     counts.set(subtype, (counts.get(subtype) ?? 0) + 1);
     const member = representativeMember(asArray(evidence2?.["memberSet"]));
     if (member)
@@ -79815,13 +79917,13 @@ function extractDeadCode(report) {
     if (!record)
       continue;
     const evidence2 = asRecord11(record["evidence"]);
-    const kind = str2(evidence2?.["exportKind"]) ?? str2(record["candidateKind"]) ?? "other";
+    const kind = str3(evidence2?.["exportKind"]) ?? str3(record["candidateKind"]) ?? "other";
     counts.set(kind, (counts.get(kind) ?? 0) + 1);
-    const path = str2(evidence2?.["path"]);
+    const path = str3(evidence2?.["path"]);
     if (path)
       paths.push(path);
     if (!top) {
-      const name = str2(record["displayName"]) ?? str2(evidence2?.["exportName"]) ?? "symbol";
+      const name = str3(record["displayName"]) ?? str3(evidence2?.["exportName"]) ?? "symbol";
       top = `${name} (${kind})${path ? ` · ${path}` : ""}`;
     }
   }
@@ -79835,14 +79937,14 @@ function extractCoverage(report) {
     const record = asRecord11(entry);
     if (!record)
       continue;
-    const path = str2(record["path"]);
+    const path = str3(record["path"]);
     if (path) {
       paths.push(path);
       if (!top)
         top = path;
     }
     for (const type of asArray(record["evidenceTypes"])) {
-      const label = str2(type);
+      const label = str3(type);
       if (label)
         counts.set(label, (counts.get(label) ?? 0) + 1);
     }
@@ -79852,7 +79954,7 @@ function extractCoverage(report) {
 function extractGeneric(report) {
   const paths = [];
   for (const candidate of asArray(report["candidates"])) {
-    const path = str2(asRecord11(candidate)?.["path"]) ?? str2(asRecord11(asRecord11(candidate)?.["evidence"])?.["path"]);
+    const path = str3(asRecord11(candidate)?.["path"]) ?? str3(asRecord11(asRecord11(candidate)?.["evidence"])?.["path"]);
     if (path)
       paths.push(path);
   }
@@ -79927,21 +80029,21 @@ function extractHotspots(report) {
     const evidence2 = asRecord11(asRecord11(candidate)?.["evidence"]);
     for (const member of asArray(evidence2?.["memberSet"])) {
       const record = asRecord11(member);
-      const symbol = str2(record?.["displayName"]);
+      const symbol = str3(record?.["displayName"]);
       const inEdges = num(record?.["inEdgeCount"]);
       if (!symbol || inEdges === undefined)
         continue;
       const display = symbol.includes("/") ? basename18(symbol) : symbol;
       const existing = best.get(symbol);
       if (!existing || inEdges > existing.inEdges)
-        best.set(symbol, { symbol: display, inEdges, path: str2(record?.["path"]) });
+        best.set(symbol, { symbol: display, inEdges, path: str3(record?.["path"]) });
     }
   }
   return [...best.values()].sort((a, b) => b.inEdges - a.inEdges).slice(0, 4);
 }
 function extractDriftTop(report) {
   const first = asRecord11(asArray(report?.["findings"])[0]);
-  return str2(first?.["path"]) ?? str2(first?.["summary"]) ?? str2(first?.["title"]) ?? str2(first?.["detail"]);
+  return str3(first?.["path"]) ?? str3(first?.["summary"]) ?? str3(first?.["title"]) ?? str3(first?.["detail"]);
 }
 async function buildModuleRows(repoPath, findings) {
   const weights = await scanModuleWeights(repoPath);
@@ -80035,10 +80137,10 @@ function representativeMember(members) {
   let fallback;
   for (const member of members) {
     const record = asRecord11(member);
-    const path = str2(record?.["path"]);
+    const path = str3(record?.["path"]);
     if (!path)
       continue;
-    if (str2(record?.["role"]) === "representative")
+    if (str3(record?.["role"]) === "representative")
       return path;
     fallback ??= path;
   }
@@ -80056,7 +80158,7 @@ function asArray(value) {
 function asRecord11(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
 }
-function str2(value) {
+function str3(value) {
   return typeof value === "string" && value.length > 0 ? value : undefined;
 }
 function num(value) {
@@ -80080,6 +80182,173 @@ function tidyPath(absolute, repoPath) {
   return rel && !rel.startsWith("..") ? rel : absolute;
 }
 
+// src/codeContextTools/symbolHistoryReader.ts
+import { join as join25 } from "node:path";
+import {
+  resolveProvenanceSymbols,
+  whatChangedSince,
+  whySymbolChanged
+} from "./vendor/rhei-core/evidenceLedger.js";
+function resolveSymbolHistoryDeps(repoPath, env = process.env) {
+  const root = localSqlArtifactRoot(repoPath, env);
+  return {
+    ledgerDbPath: join25(root, "evidence-ledger.sqlite"),
+    codeIndexDbPath: join25(root, "code-index.sqlite")
+  };
+}
+async function loadSqlite() {
+  try {
+    return await import("node:sqlite");
+  } catch {
+    return;
+  }
+}
+function openReadOnly(mod, path) {
+  try {
+    return new mod.DatabaseSync(path, { readOnly: true });
+  } catch {
+    return;
+  }
+}
+function parseStringArray(value) {
+  if (typeof value !== "string" || value.length === 0)
+    return [];
+  try {
+    const parsed = JSON.parse(value);
+    return Array.isArray(parsed) ? parsed.filter((entry) => typeof entry === "string") : [];
+  } catch {
+    return [];
+  }
+}
+function toProvenanceRow(raw) {
+  return {
+    provenanceId: raw.provenance_id,
+    goal: raw.goal ?? undefined,
+    actor: raw.actor ?? undefined,
+    createdAt: raw.created_at ?? undefined,
+    files: parseStringArray(raw.files_json),
+    symbols: parseStringArray(raw.symbols_json)
+  };
+}
+function symbolSpansForPaths(db, paths) {
+  const unique = [...new Set(paths)].filter(Boolean);
+  if (unique.length === 0)
+    return [];
+  const placeholders = unique.map(() => "?").join(",");
+  const rows = db.prepare(`SELECT COALESCE(s.qualified_name, s.name) AS key, f.path AS path,
+              s.start_line AS startLine, s.end_line AS endLine
+       FROM symbols s JOIN files f ON f.file_id = s.file_id
+       WHERE f.path IN (${placeholders})`).all(...unique);
+  return rows.map((row) => ({
+    key: String(row["key"]),
+    path: String(row["path"]),
+    startLine: Number(row["startLine"]),
+    endLine: Number(row["endLine"])
+  }));
+}
+function definingPathsForSymbol(db, symbol) {
+  const rows = db.prepare(`SELECT DISTINCT f.path AS path FROM symbols s JOIN files f ON f.file_id = s.file_id
+       WHERE s.qualified_name = ? OR s.name = ?`).all(symbol, symbol);
+  return rows.map((row) => String(row["path"]));
+}
+function provenanceRowsTouchingPaths(db, paths) {
+  const unique = [...new Set(paths)].filter(Boolean);
+  if (unique.length === 0)
+    return [];
+  const likeClause = unique.map(() => "files_json LIKE ?").join(" OR ");
+  const likeParams = unique.map((path) => `%${JSON.stringify(path)}%`);
+  const rows = db.prepare(`SELECT provenance_id, goal, actor, created_at, files_json, symbols_json
+       FROM edit_provenance WHERE ${likeClause} ORDER BY created_at DESC`).all(...likeParams);
+  const want = new Set(unique);
+  return rows.map(toProvenanceRow).filter((row) => (row.files ?? []).some((file) => want.has(file)));
+}
+async function resolveSinceMs(query2) {
+  if (typeof query2.sinceMs === "number" && Number.isFinite(query2.sinceMs))
+    return query2.sinceMs;
+  if (query2.sinceRef && query2.repoPath) {
+    try {
+      const { execFileSync: execFileSync5 } = await import("node:child_process");
+      const out = execFileSync5("git", ["-C", query2.repoPath, "log", "-1", "--format=%ct", query2.sinceRef], {
+        encoding: "utf8",
+        timeout: 2000,
+        windowsHide: true
+      }).trim();
+      const seconds = Number.parseInt(out, 10);
+      if (Number.isFinite(seconds))
+        return seconds * 1000;
+    } catch {}
+  }
+  return;
+}
+var EMPTY_WHAT_CHANGED = {
+  sinceMs: 0,
+  editCount: 0,
+  files: [],
+  symbols: [],
+  goals: []
+};
+async function whatChangedSinceFromLedger(query2, deps) {
+  const sinceMs = await resolveSinceMs(query2);
+  const mod = await loadSqlite();
+  if (!mod || sinceMs === undefined)
+    return { ...EMPTY_WHAT_CHANGED, sinceMs: sinceMs ?? 0, available: false };
+  const ledger = openReadOnly(mod, deps.ledgerDbPath);
+  if (!ledger)
+    return { ...EMPTY_WHAT_CHANGED, sinceMs, available: false };
+  try {
+    const raw = ledger.prepare(`SELECT provenance_id, goal, actor, created_at, files_json, symbols_json
+         FROM edit_provenance WHERE created_at >= ? ORDER BY created_at DESC`).all(sinceMs);
+    const rows = raw.map(toProvenanceRow);
+    const resolved = withResolvedSymbols(mod, deps, rows);
+    return { ...whatChangedSince({ sinceMs }, resolved), available: true };
+  } catch {
+    return { ...EMPTY_WHAT_CHANGED, sinceMs, available: false };
+  } finally {
+    ledger.close();
+  }
+}
+async function whySymbolChangedFromLedger(symbol, deps) {
+  const empty = { symbol, editCount: 0, edits: [], goals: [] };
+  const mod = await loadSqlite();
+  if (!mod)
+    return { ...empty, available: false };
+  const index = openReadOnly(mod, deps.codeIndexDbPath);
+  const ledger = openReadOnly(mod, deps.ledgerDbPath);
+  if (!index || !ledger) {
+    index?.close();
+    ledger?.close();
+    return { ...empty, available: false };
+  }
+  try {
+    const paths = definingPathsForSymbol(index, symbol);
+    if (paths.length === 0)
+      return { ...empty, available: true };
+    const rows = provenanceRowsTouchingPaths(ledger, paths).map((row) => ({
+      ...row,
+      symbols: [...new Set([...row.symbols ?? [], symbol])]
+    }));
+    return { ...whySymbolChanged(symbol, rows), available: true };
+  } catch {
+    return { ...empty, available: false };
+  } finally {
+    index.close();
+    ledger.close();
+  }
+}
+function withResolvedSymbols(mod, deps, rows) {
+  const paths = rows.flatMap((row) => row.files ?? []);
+  if (paths.length === 0)
+    return [...rows];
+  const index = openReadOnly(mod, deps.codeIndexDbPath);
+  if (!index)
+    return [...rows];
+  try {
+    return resolveProvenanceSymbols(rows, symbolSpansForPaths(index, paths));
+  } finally {
+    index.close();
+  }
+}
+
 // src/tools.ts
 var ENTITY_TYPES = [
   "character",
@@ -81741,8 +82010,46 @@ async function executeRemoteBetaTool(toolName, args, config) {
     });
   }
   if (toolName === "ledger") {
+    const repoPath = typeof args["repoPath"] === "string" ? args["repoPath"] : undefined;
+    const opRaw = typeof args["op"] === "string" ? args["op"].trim().toLowerCase() : "overview";
+    if (opRaw === "why_symbol_changed" || opRaw === "what_changed_since") {
+      const deps = resolveSymbolHistoryDeps(repoPath ?? process.cwd());
+      if (opRaw === "why_symbol_changed") {
+        const symbol = typeof args["symbol"] === "string" ? args["symbol"].trim() : "";
+        const result2 = symbol ? await whySymbolChangedFromLedger(symbol, deps) : { symbol: "", editCount: 0, edits: [], goals: [], available: false };
+        return textJsonResult({
+          kind: "rhei_ledger",
+          schemaVersion: 1,
+          op: "why_symbol_changed",
+          status: result2.available ? "ready" : "unavailable",
+          whySymbolChanged: result2,
+          reportOnly: true,
+          advisoryOnly: true,
+          noAuthority: true,
+          candidatesNotProof: true,
+          sourceWrites: false,
+          productionAuthority: false
+        });
+      }
+      const sinceMs = typeof args["sinceMs"] === "number" ? args["sinceMs"] : undefined;
+      const sinceRef = typeof args["sinceRef"] === "string" ? args["sinceRef"] : undefined;
+      const result = await whatChangedSinceFromLedger({ sinceMs, sinceRef, repoPath }, deps);
+      return textJsonResult({
+        kind: "rhei_ledger",
+        schemaVersion: 1,
+        op: "what_changed_since",
+        status: result.available ? "ready" : "unavailable",
+        whatChangedSince: result,
+        reportOnly: true,
+        advisoryOnly: true,
+        noAuthority: true,
+        candidatesNotProof: true,
+        sourceWrites: false,
+        productionAuthority: false
+      });
+    }
     const overview = await buildStatusOverview({
-      repoPath: typeof args["repoPath"] === "string" ? args["repoPath"] : undefined,
+      repoPath,
       full: true,
       skipMcpSmoke: true,
       mcp: {
@@ -81753,7 +82060,6 @@ async function executeRemoteBetaTool(toolName, args, config) {
       }
     });
     const evidenceLedger = overview.overview["evidenceLedger"];
-    const opRaw = typeof args["op"] === "string" ? args["op"].trim().toLowerCase() : "overview";
     const op = opRaw === "report_cards" || opRaw === "trust_diff" || opRaw === "explain_line" ? opRaw : "overview";
     const line = evidenceLedger ? evidenceLedgerLine(evidenceLedger) : undefined;
     return textJsonResult({
@@ -82538,8 +82844,6 @@ function createLocalCodeContextServer(args) {
   };
   const explicitAllowlist = process.env["RHEI_MCP_LOCAL_TOOL_ALLOWLIST"] !== undefined;
   for (const tool of RHEI_LOCAL_STATUS_TOOLS) {
-    if (!publicLocalToolNameSet.has(tool.name))
-      continue;
     if (explicitAllowlist && localToolAllowlist && !localToolAllowlist.has(tool.name))
       continue;
     if (!explicitAllowlist && toolSurface !== "top_level_orchestrator")

package/dist/vendor/rhei-core/changeEpisode.js

@@ -0,0 +1,288 @@
+// ../core/src/changeEpisode/types.ts
+var CHANGE_EPISODE_SCHEMA_VERSION = 1;
+// ../core/src/changeEpisode/builders.ts
+var CHANGE_EPISODE_ACTORS = ["human", "agent", "mixed"];
+var CLOSED_EPISODE_STATUSES = [
+  "validated",
+  "failed",
+  "reverted",
+  "committed"
+];
+function openChangeEpisode(input) {
+  if (!CHANGE_EPISODE_ACTORS.includes(input.actor)) {
+    throw new Error(`openChangeEpisode: invalid actor "${String(input.actor)}"`);
+  }
+  if (!isValidTimestamp(input.startedAt)) {
+    throw new Error(`openChangeEpisode: invalid startedAt ${String(input.startedAt)}`);
+  }
+  const episodeId = cleanString(input.episodeId) ?? `change-episode:${stableHash({
+    goalId: input.goalId,
+    actor: input.actor,
+    startedAt: input.startedAt,
+    goal: input.goal,
+    gitBaseSha: input.gitBaseSha
+  })}`;
+  return removeUndefined({
+    episodeId,
+    goalId: cleanString(input.goalId),
+    actor: input.actor,
+    startedAt: input.startedAt,
+    goal: cleanString(input.goal),
+    contextReceipts: uniqueStrings(input.contextReceipts ?? []),
+    fileDeltas: uniqueStrings(input.fileDeltas ?? []),
+    symbolDeltas: uniqueStrings(input.symbolDeltas ?? []),
+    edgeDeltas: uniqueStrings(input.edgeDeltas ?? []),
+    memoryDeltas: uniqueStrings(input.memoryDeltas ?? []),
+    validationRuns: uniqueStrings(input.validationRuns ?? []),
+    gitBaseSha: cleanString(input.gitBaseSha),
+    worktreeDirtyHashBefore: cleanString(input.worktreeDirtyHashBefore),
+    status: "open"
+  });
+}
+function attachEpisodeRows(episode, rows) {
+  return {
+    ...episode,
+    contextReceipts: uniqueStrings([...episode.contextReceipts, ...rows.contextReceipts ?? []]),
+    fileDeltas: uniqueStrings([...episode.fileDeltas, ...rows.fileDeltas ?? []]),
+    symbolDeltas: uniqueStrings([...episode.symbolDeltas, ...rows.symbolDeltas ?? []]),
+    edgeDeltas: uniqueStrings([...episode.edgeDeltas, ...rows.edgeDeltas ?? []]),
+    memoryDeltas: uniqueStrings([...episode.memoryDeltas, ...rows.memoryDeltas ?? []]),
+    validationRuns: uniqueStrings([...episode.validationRuns, ...rows.validationRuns ?? []])
+  };
+}
+function closeChangeEpisode(episode, input) {
+  if (episode.status !== "open") {
+    throw new Error(`closeChangeEpisode: episode ${episode.episodeId} is already closed (status "${episode.status}")`);
+  }
+  if (!CLOSED_EPISODE_STATUSES.includes(input.status)) {
+    throw new Error(`closeChangeEpisode: invalid target status "${String(input.status)}"`);
+  }
+  if (!isValidTimestamp(input.endedAt) || input.endedAt < episode.startedAt) {
+    throw new Error(`closeChangeEpisode: invalid endedAt ${String(input.endedAt)} (startedAt ${episode.startedAt})`);
+  }
+  return removeUndefined({
+    ...episode,
+    status: input.status,
+    endedAt: input.endedAt,
+    gitHeadSha: cleanString(input.gitHeadSha) ?? episode.gitHeadSha,
+    worktreeDirtyHashAfter: cleanString(input.worktreeDirtyHashAfter) ?? episode.worktreeDirtyHashAfter
+  });
+}
+function planEpisodeRevert(episode, fileDeltas, opts = {}) {
+  const deltasById = new Map;
+  for (const delta of fileDeltas) {
+    if (!deltasById.has(delta.fileDeltaId))
+      deltasById.set(delta.fileDeltaId, delta);
+  }
+  const deltasToInvert = [];
+  const deltasExcluded = [];
+  const conflicts = [];
+  for (const fileDeltaId of uniqueStrings(episode.fileDeltas)) {
+    const delta = deltasById.get(fileDeltaId);
+    if (!delta) {
+      conflicts.push({ fileDeltaId, reason: "missing_delta_row" });
+      continue;
+    }
+    const currentPath = cleanString(delta.pathAfter) ?? cleanString(delta.pathBefore);
+    if (currentPath !== undefined && opts.excludePaths?.(currentPath) === true) {
+      deltasExcluded.push({ id: fileDeltaId, reason: "excluded_by_filter" });
+      continue;
+    }
+    if (cleanString(delta.inversePatch) === undefined) {
+      conflicts.push({ fileDeltaId, reason: "no_inverse_patch" });
+      continue;
+    }
+    deltasToInvert.push(fileDeltaId);
+  }
+  const status = deltasToInvert.length === 0 ? "blocked" : conflicts.length > 0 || deltasExcluded.length > 0 ? "partial" : "plannable";
+  return {
+    episodeId: episode.episodeId,
+    deltasToInvert,
+    deltasExcluded,
+    conflicts,
+    status
+  };
+}
+function fileDeltasFromProvenance(rows) {
+  return rows.map((row) => {
+    const actor = (() => {
+      const value = cleanString(row.actor);
+      return value === "human" || value?.startsWith("human_") ? "human" : "agent";
+    })();
+    return removeUndefined({
+      fileDeltaId: row.provenanceId,
+      pathBefore: cleanString(row.pathBefore),
+      pathAfter: cleanString(row.pathAfter),
+      changeKind: row.changeKind ?? "modify",
+      beforeHash: cleanString(row.beforeHash),
+      afterHash: cleanString(row.afterHash),
+      forwardPatch: cleanString(row.forwardPatch),
+      inversePatch: cleanString(row.inversePatch),
+      actor,
+      receiptId: row.provenanceId
+    });
+  });
+}
+function uniqueStrings(values) {
+  return Array.from(new Set(values.map((value) => value?.trim()).filter((value) => Boolean(value))));
+}
+function cleanString(value) {
+  if (typeof value !== "string")
+    return;
+  const text = value.trim();
+  return text.length > 0 ? text : undefined;
+}
+function isValidTimestamp(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+function removeUndefined(value) {
+  return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined));
+}
+function stableHash(value) {
+  const text = stableJson(value);
+  let hash = 2166136261;
+  for (let index = 0;index < text.length; index += 1) {
+    hash ^= text.charCodeAt(index);
+    hash = Math.imul(hash, 16777619);
+  }
+  return (hash >>> 0).toString(16).padStart(8, "0").slice(0, 12);
+}
+function stableJson(value) {
+  if (Array.isArray(value))
+    return `[${value.map(stableJson).join(",")}]`;
+  if (value && typeof value === "object") {
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${stableJson(value[key])}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}
+// ../core/src/changeEpisode/fromLedgerRows.ts
+function assembleChangeEpisodeFromLedgerRows(input) {
+  const provenance = input.editProvenance.filter((row) => row.goalId === undefined || row.goalId === input.goalId);
+  const timestamps = [
+    ...input.trials.map((trial) => trial.createdAt),
+    ...provenance.map((row) => row.createdAt)
+  ].filter((value) => typeof value === "number" && Number.isFinite(value));
+  const startedAt = timestamps.length > 0 ? Math.min(...timestamps) : input.fallbackStartedAt ?? 0;
+  const episode = openChangeEpisode({
+    goalId: input.goalId,
+    goal: input.goal,
+    actor: inferEpisodeActor(provenance),
+    startedAt,
+    gitBaseSha: input.gitBaseSha,
+    worktreeDirtyHashBefore: input.worktreeDirtyHashBefore
+  });
+  return attachEpisodeRows(episode, {
+    contextReceipts: uniqueStrings([
+      ...input.packItems.map((item) => item.trialId),
+      ...input.trials.map((trial) => trial.receiptId)
+    ]),
+    fileDeltas: provenance.map((row) => row.provenanceId),
+    symbolDeltas: provenance.flatMap((row) => [...row.symbols ?? []]),
+    validationRuns: [...input.validationRefs]
+  });
+}
+function inferEpisodeActor(provenance) {
+  let hasAgent = false;
+  let hasHuman = false;
+  for (const row of provenance) {
+    const actor = cleanString(row.actor);
+    if (actor === undefined)
+      continue;
+    if (actor === "human" || actor.startsWith("human_"))
+      hasHuman = true;
+    else
+      hasAgent = true;
+  }
+  if (hasAgent && hasHuman)
+    return "mixed";
+  if (hasHuman)
+    return "human";
+  return "agent";
+}
+// ../core/src/changeEpisode/deltaComputation.ts
+function isUsableRange(range) {
+  return Number.isFinite(range.startLine) && Number.isFinite(range.endLine) && range.endLine >= range.startLine && (range.startLine > 0 || range.endLine > 0);
+}
+function overlaps(span, range) {
+  return span.startLine <= range.endLine && span.endLine >= range.startLine;
+}
+function resolveTouchedSymbols(changedPaths, symbols, hunks) {
+  const changed = new Set(changedPaths.map((path) => path.trim()).filter(Boolean));
+  const usableHunksByPath = new Map;
+  for (const hunk of hunks ?? []) {
+    if (!isUsableRange(hunk))
+      continue;
+    const list = usableHunksByPath.get(hunk.path) ?? [];
+    list.push(hunk);
+    usableHunksByPath.set(hunk.path, list);
+  }
+  const seen = new Set;
+  const touched = [];
+  for (const symbol of symbols) {
+    if (!changed.has(symbol.path))
+      continue;
+    const pathHunks = usableHunksByPath.get(symbol.path);
+    const isTouched = pathHunks === undefined ? true : pathHunks.some((range) => overlaps(symbol, range));
+    if (!isTouched)
+      continue;
+    const key = symbol.key.trim();
+    if (!key || seen.has(key))
+      continue;
+    seen.add(key);
+    touched.push(key);
+  }
+  return touched;
+}
+function deriveInverseEdit(spec) {
+  switch (spec.kind) {
+    case "search_replace":
+      return { kind: "search_replace", path: spec.path, search: spec.replace, replace: spec.search };
+    case "rewrite":
+      return spec.beforeContent === undefined ? { kind: "unavailable", path: spec.path, reason: "missing_before_content" } : { kind: "rewrite", path: spec.path, rewrite: spec.beforeContent };
+    case "create":
+      return { kind: "delete", path: spec.path };
+    case "delete":
+      return spec.beforeContent === undefined ? { kind: "unavailable", path: spec.path, reason: "missing_before_content" } : { kind: "create", path: spec.path, content: spec.beforeContent };
+  }
+}
+function edgeIdentity(edge) {
+  return `${edge.from}\x00${edge.to}\x00${edge.kind}`;
+}
+function diffGraphEdges(prev, next) {
+  const prevIds = new Set(prev.map(edgeIdentity));
+  const nextIds = new Set(next.map(edgeIdentity));
+  const added = [];
+  const seenAdded = new Set;
+  for (const edge of next) {
+    const id = edgeIdentity(edge);
+    if (prevIds.has(id) || seenAdded.has(id))
+      continue;
+    seenAdded.add(id);
+    added.push({ change: "added", from: edge.from, to: edge.to, kind: edge.kind });
+  }
+  const removed = [];
+  const seenRemoved = new Set;
+  for (const edge of prev) {
+    const id = edgeIdentity(edge);
+    if (nextIds.has(id) || seenRemoved.has(id))
+      continue;
+    seenRemoved.add(id);
+    removed.push({ change: "removed", from: edge.from, to: edge.to, kind: edge.kind });
+  }
+  return [...added, ...removed];
+}
+export {
+  uniqueStrings,
+  stableHash,
+  resolveTouchedSymbols,
+  planEpisodeRevert,
+  openChangeEpisode,
+  fileDeltasFromProvenance,
+  diffGraphEdges,
+  deriveInverseEdit,
+  closeChangeEpisode,
+  cleanString,
+  attachEpisodeRows,
+  assembleChangeEpisodeFromLedgerRows,
+  CHANGE_EPISODE_SCHEMA_VERSION
+};

package/dist/vendor/rhei-core/evidenceLedger.js

@@ -4092,11 +4092,13 @@ var EditSourceV1Schema = exports_external.enum([
   "shell_script",
   "unknown_external_agent"
 ]);
+var EditHunkInverseV1Schema = exports_external.object({ kind: exports_external.string() }).passthrough();
 var EditHunkV1Schema = exports_external.object({
   filePath: exports_external.string(),
   startLine: exports_external.number().int().nonnegative(),
   endLine: exports_external.number().int().nonnegative(),
-  kind: exports_external.enum(["insert", "update", "delete", "mixed"]).optional()
+  kind: exports_external.enum(["insert", "update", "delete", "mixed"]).optional(),
+  inverse: exports_external.array(EditHunkInverseV1Schema).optional()
 }).strict();
 var EditProvenanceV1Schema = exports_external.object({
   schemaVersion: exports_external.literal(EVIDENCE_LEDGER_SCHEMA_VERSION),
@@ -5084,6 +5086,100 @@ function buildProvenanceSourceReportCards(provenances, events, options = {}) {
     return card;
   }).sort((a, b) => b.totalEdits - a.totalEdits || a.source.localeCompare(b.source));
 }
+// ../core/src/changeEpisode/deltaComputation.ts
+function isUsableRange(range) {
+  return Number.isFinite(range.startLine) && Number.isFinite(range.endLine) && range.endLine >= range.startLine && (range.startLine > 0 || range.endLine > 0);
+}
+function overlaps(span, range) {
+  return span.startLine <= range.endLine && span.endLine >= range.startLine;
+}
+function resolveTouchedSymbols(changedPaths, symbols, hunks) {
+  const changed = new Set(changedPaths.map((path) => path.trim()).filter(Boolean));
+  const usableHunksByPath = new Map;
+  for (const hunk of hunks ?? []) {
+    if (!isUsableRange(hunk))
+      continue;
+    const list = usableHunksByPath.get(hunk.path) ?? [];
+    list.push(hunk);
+    usableHunksByPath.set(hunk.path, list);
+  }
+  const seen = new Set;
+  const touched = [];
+  for (const symbol of symbols) {
+    if (!changed.has(symbol.path))
+      continue;
+    const pathHunks = usableHunksByPath.get(symbol.path);
+    const isTouched = pathHunks === undefined ? true : pathHunks.some((range) => overlaps(symbol, range));
+    if (!isTouched)
+      continue;
+    const key = symbol.key.trim();
+    if (!key || seen.has(key))
+      continue;
+    seen.add(key);
+    touched.push(key);
+  }
+  return touched;
+}
+// ../core/src/evidenceLedger/symbolHistory.ts
+function sortRowsMostRecentFirst(rows) {
+  return [...rows].sort((left, right) => timestamp(right.createdAt) - timestamp(left.createdAt));
+}
+function timestamp(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : Number.NEGATIVE_INFINITY;
+}
+function pushUnique(seen, into, value) {
+  const text = value?.trim();
+  if (!text || seen.has(text))
+    return;
+  seen.add(text);
+  into.push(text);
+}
+function resolveProvenanceSymbols(rows, indexSymbols) {
+  return rows.map((row) => {
+    if ((row.symbols ?? []).length > 0)
+      return row;
+    const symbols = resolveTouchedSymbols([...row.files ?? []], indexSymbols);
+    return { ...row, symbols };
+  });
+}
+function whySymbolChanged(symbolKey, rows) {
+  const target = symbolKey.trim();
+  const ordered = sortRowsMostRecentFirst(rows);
+  const edits = [];
+  const goalSeen = new Set;
+  const goals = [];
+  for (const row of ordered) {
+    if (!(row.symbols ?? []).some((symbol) => symbol.trim() === target))
+      continue;
+    edits.push({
+      provenanceId: row.provenanceId,
+      goalId: row.goalId,
+      goal: row.goal,
+      actor: row.actor,
+      changedAt: row.createdAt,
+      files: [...row.files ?? []]
+    });
+    pushUnique(goalSeen, goals, row.goal);
+  }
+  return { symbol: target, editCount: edits.length, edits, goals };
+}
+function whatChangedSince(input, rows) {
+  const ordered = sortRowsMostRecentFirst(rows).filter((row) => timestamp(row.createdAt) >= input.sinceMs);
+  const fileSeen = new Set;
+  const files = [];
+  const symbolSeen = new Set;
+  const symbols = [];
+  const goalSeen = new Set;
+  const goals = [];
+  for (const row of ordered) {
+    for (const file of row.files ?? [])
+      pushUnique(fileSeen, files, file);
+    for (const symbol of row.symbols ?? [])
+      pushUnique(symbolSeen, symbols, symbol);
+    pushUnique(goalSeen, goals, row.goal);
+  }
+  return { sinceMs: input.sinceMs, editCount: ordered.length, files, symbols, goals };
+}
 // ../core/src/evidenceLedger/ddl.ts
 var EVIDENCE_LEDGER_DDL = `-- Evidence Ledger canonical DDL (SPEC ONLY).
 --
@@ -5236,8 +5332,11 @@ var EVIDENCE_LEDGER_TABLE_NAMES = [
   "memory_signals"
 ];
 export {
+  whySymbolChanged,
+  whatChangedSince,
   usefulnessForIntent,
   unsafeTeamEvidenceMetadataPayloadPaths,
+  resolveProvenanceSymbols,
   rankSubjectsForIntent,
   parseGitNameOnlyLog,
   nextMemoryStatus,
@@ -5325,6 +5424,7 @@ export {
   EditSourceV1Schema,
   EditProvenanceV1Schema,
   EditHunkV1Schema,
+  EditHunkInverseV1Schema,
   EVIDENCE_LEDGER_TABLE_NAMES,
   EVIDENCE_LEDGER_SCHEMA_VERSION,
   EVIDENCE_LEDGER_DDL,

package/dist/vendor/rhei-core/package.json

@@ -4,6 +4,7 @@
   "type": "module",
   "exports": {
     "./briefs": "./briefs.js",
+    "./changeEpisode": "./changeEpisode.js",
     "./codeAgent": "./codeAgent.js",
     "./codeEditSession": "./codeEditSession.js",
     "./codeIntelligence": "./codeIntelligence.js",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rhei-team/rhei",
-  "version": "1.0.0-beta.0",
+  "version": "1.0.0-beta.1",
   "description": "Local-first MCP server for Rhei Code Context and governed agent handoffs",
   "type": "module",
   "license": "UNLICENSED",