avorelo 0.3.5 → 0.3.6

package/dist/avorelo.mjs

@@ -2562,6 +2562,7 @@ function buildCapabilityRouteDecision(input) {
   const proposalHints = unique(input.proposalHints ?? []);
   const allowedLegacyFeatures = input.allowedLegacyFeatures ?? [];
   pushCapability(selected, expectedEvidence, reasonCodes, "context-check", "CONTEXT_CHECK_REUSED", ["context_check_result"]);
+  pushCapability(selected, expectedEvidence, reasonCodes, "context-control", "CONTEXT_CONTROL_ACTIVE", ["context_control_summary"]);
   pushCapability(selected, expectedEvidence, reasonCodes, "tool-governance", "TOOL_GOVERNANCE_REUSED", ["tool_routing_projection"]);
   pushCapability(selected, expectedEvidence, reasonCodes, "receipt-trace", "KERNEL_RECEIPTS_REUSED", ["kernel_receipt_ref"]);
   pushCapability(selected, expectedEvidence, reasonCodes, "model-routing", "MODEL_ROUTING_SUBORDINATE", ["model_routing_projection"]);
@@ -2752,7 +2753,8 @@ var init_work_controls = __esm({
       "loop-control",
       "drift-guard",
       "company-loop",
-      "founder-cockpit"
+      "founder-cockpit",
+      "context-control"
     ];
     CAPABILITY_TO_LEGACY_FEATURE = {
       "production-confidence": "visual-proof",
@@ -8120,7 +8122,7 @@ function runFullActivation(targetDir) {
   const dashboardPath = join27(targetDir, ".avorelo", "dashboard", "index.html");
   const localDashboard = { available: existsSync30(dashboardPath), path: existsSync30(dashboardPath) ? dashboardPath : void 0 };
   const blockers = repairsBlocked.length;
-  const activationStatus = blockers > 0 ? "blocked" : "active_with_holds";
+  const activationStatus = blockers > 0 ? "blocked" : "active";
   const existingState = readActivationState(targetDir);
   const workspaceId = existingState?.workspaceId || makeWorkspaceId(targetDir);
   const state = {
@@ -8845,7 +8847,7 @@ import { join as join40 } from "node:path";
 
 // src/avorelo/capabilities/runtime-flow/index.ts
 init_entitlement_resolver();
-import { createHash as createHash12 } from "node:crypto";
+import { createHash as createHash13 } from "node:crypto";
 import { mkdirSync as mkdirSync24, writeFileSync as writeFileSync23, appendFileSync as appendFileSync9, readFileSync as readFileSync23, existsSync as existsSync39 } from "node:fs";
 import { join as join39 } from "node:path";
 
@@ -11473,6 +11475,1281 @@ function buildSummary(status, sourceCount, findingCount) {
   return `Checked ${sourceCount} instruction source(s). ${findingCount} finding(s) detected.`;
 }
 
+// src/avorelo/kernel/context-control/classify.ts
+var SECRET_PATTERNS2 = [
+  /(?:api[_-]?key|apikey)\s*[:=]\s*\S+/i,
+  /(?:secret|token|password|passwd|pwd)\s*[:=]\s*\S+/i,
+  /(?:aws|gcp|azure)[_-](?:access|secret|key)\s*[:=]/i,
+  /-----BEGIN (?:RSA |EC )?PRIVATE KEY-----/,
+  /(?:sk-|pk-|rk-)[a-zA-Z0-9]{20,}/,
+  /ghp_[a-zA-Z0-9]{36}/,
+  /glpat-[a-zA-Z0-9_-]{20,}/,
+  /xox[bpsa]-[a-zA-Z0-9-]+/
+];
+var FORBIDDEN_PATTERNS = [
+  /PRIVATE[_ ]KEY/,
+  /\.env\b/,
+  /credentials\.json/,
+  /id_rsa/,
+  /-----BEGIN (?:RSA |EC )?PRIVATE KEY-----/
+];
+function classifyContentType(content, label) {
+  const lower = label.toLowerCase();
+  const trimmed = content.slice(0, 2e3);
+  if (lower.includes("log") || lower.includes("output")) {
+    if (/^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}/.test(trimmed)) return "log";
+    if (/\b(?:ERROR|WARN|INFO|DEBUG|FATAL)\b/.test(trimmed)) return "log";
+    if (/(?:exit code|exited with|status:)\s*\d/i.test(trimmed)) return "log";
+  }
+  if (lower.includes("test")) {
+    if (/(?:PASS|FAIL|✓|✗|passed|failed)\s/i.test(trimmed)) return "test_output";
+    if (/(?:tests?|specs?|suites?)\s+\d+/i.test(trimmed)) return "test_output";
+  }
+  if (lower.includes("diff") || lower.includes("patch")) return "diff";
+  if (lower.includes("tree") || lower.includes("directory")) return "file_tree";
+  if (lower.includes("conversation") || lower.includes("history") || lower.includes("session")) return "conversation_history";
+  if (lower.includes("receipt") || lower.includes("proof") || lower.includes("evidence")) return "receipt_proof_evidence";
+  if (lower.includes("doc") || lower.includes("readme") || lower.includes("markdown")) return "documentation";
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+    try {
+      JSON.parse(content);
+      return "json_tool_output";
+    } catch {
+    }
+  }
+  if (/^diff --git/.test(trimmed) || /^@@\s/.test(trimmed)) return "diff";
+  if (/^[├└│─\s]+/.test(trimmed) || /^\s*[a-z_-]+\/$/m.test(trimmed)) return "file_tree";
+  if (/\b(?:function|class|const|let|var|import|export|def |async )\b/.test(trimmed)) return "source_like";
+  return "unknown";
+}
+function classifySensitivity(content) {
+  for (const pattern of FORBIDDEN_PATTERNS) {
+    if (pattern.test(content)) return "forbidden";
+  }
+  for (const pattern of SECRET_PATTERNS2) {
+    if (pattern.test(content)) return "secret_like";
+  }
+  if (/\b(?:internal|private|confidential)\b/i.test(content.slice(0, 500))) return "internal";
+  return "public";
+}
+function classifyPersistence(sensitivity) {
+  switch (sensitivity) {
+    case "forbidden":
+      return { safeForModel: false, safeForPersistence: false, safeForCloudSync: false, localOnly: true, forbidden: true };
+    case "secret_like":
+      return { safeForModel: false, safeForPersistence: false, safeForCloudSync: false, localOnly: true, forbidden: false };
+    case "local_only":
+      return { safeForModel: true, safeForPersistence: true, safeForCloudSync: false, localOnly: true, forbidden: false };
+    case "internal":
+      return { safeForModel: true, safeForPersistence: true, safeForCloudSync: false, localOnly: false, forbidden: false };
+    case "public":
+      return { safeForModel: true, safeForPersistence: true, safeForCloudSync: true, localOnly: false, forbidden: false };
+  }
+}
+function classifyVolatility(contentType) {
+  switch (contentType) {
+    case "documentation":
+    case "receipt_proof_evidence":
+      return "stable";
+    case "file_tree":
+    case "source_like":
+      return "semi_stable";
+    default:
+      return "volatile";
+  }
+}
+function classifyEvidenceRequirement(contentType, sensitivity) {
+  if (sensitivity === "forbidden") return "forbidden";
+  if (contentType === "receipt_proof_evidence") return "proof_critical";
+  if (contentType === "test_output" || contentType === "diff") return "proof_critical";
+  if (contentType === "log") return "helpful";
+  if (contentType === "file_tree") return "noise";
+  return "helpful";
+}
+function classifyRoleRelevance(contentType) {
+  switch (contentType) {
+    case "log":
+    case "test_output":
+      return ["executor", "reviewer", "proof_adapter"];
+    case "diff":
+      return ["reviewer", "proof_adapter"];
+    case "json_tool_output":
+      return ["executor", "reviewer"];
+    case "file_tree":
+      return ["executor"];
+    case "receipt_proof_evidence":
+      return ["proof_adapter", "receipt", "status"];
+    case "conversation_history":
+      return ["executor"];
+    case "documentation":
+      return ["executor", "reviewer"];
+    default:
+      return ["executor"];
+  }
+}
+function estimateTokens(content) {
+  return Math.ceil(content.length / 4);
+}
+function classifyItem(item2) {
+  const contentType = classifyContentType(item2.content, item2.label);
+  const sensitivity = classifySensitivity(item2.content);
+  const persistence = classifyPersistence(sensitivity);
+  const volatility = classifyVolatility(contentType);
+  const evidenceRequirement = classifyEvidenceRequirement(contentType, sensitivity);
+  const roleRelevance = classifyRoleRelevance(contentType);
+  const tokens = estimateTokens(item2.content);
+  return {
+    contentType,
+    sensitivity,
+    persistence,
+    roleRelevance,
+    volatility,
+    evidenceRequirement,
+    estimatedTokens: tokens
+  };
+}
+function containsSecrets(content) {
+  return SECRET_PATTERNS2.some((p) => p.test(content));
+}
+function containsForbiddenContent(content) {
+  return FORBIDDEN_PATTERNS.some((p) => p.test(content));
+}
+
+// src/avorelo/kernel/context-control/evidence-store.ts
+import { createHash as createHash12 } from "node:crypto";
+var evidenceCounter = 0;
+function createEvidenceRef(kind, sourceType, safeSummary, originalContent) {
+  evidenceCounter++;
+  const hash = createHash12("sha256").update(originalContent).digest("hex").slice(0, 16);
+  return {
+    id: `ctx-ev-${Date.now()}-${evidenceCounter}`,
+    kind,
+    sourceType,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    localOnly: true,
+    safeSummary: safeSummary.slice(0, 200),
+    retrievalPolicy: "available",
+    redactionStatus: "clean",
+    provenanceTags: [],
+    contentHash: hash
+  };
+}
+function createBlockedEvidenceRef(sourceType, reason) {
+  evidenceCounter++;
+  return {
+    id: `ctx-ev-blocked-${Date.now()}-${evidenceCounter}`,
+    kind: "BLOCKED",
+    sourceType,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    localOnly: true,
+    safeSummary: `Blocked: ${reason.slice(0, 150)}`,
+    retrievalPolicy: "forbidden",
+    redactionStatus: "forbidden",
+    provenanceTags: [],
+    contentHash: ""
+  };
+}
+
+// src/avorelo/kernel/context-control/reducers/logs.ts
+var ERROR_PATTERNS = [
+  /\b(?:ERROR|FATAL|CRITICAL|PANIC)\b/i,
+  /\bfailed\b/i,
+  /\berror\b/i,
+  /\bException\b/,
+  /\bTraceback\b/,
+  /exit code [1-9]/i,
+  /exited with (?:code )?[1-9]/i,
+  /\bsegfault\b/i,
+  /\bOOM\b/,
+  /\bkilled\b/i
+];
+var WARNING_PATTERNS = [
+  /\bWARN(?:ING)?\b/i,
+  /\bdeprecated\b/i,
+  /\bskipped\b/i
+];
+var COMMAND_PATTERNS = [
+  /^\$\s+.+/m,
+  /^>\s+.+/m,
+  /^Running\s+/m,
+  /^Executing\s+/m
+];
+var SECRET_LINE_PATTERNS = [
+  /(?:api[_-]?key|apikey|secret|token|password|passwd|pwd)\s*[:=]\s*\S+/i,
+  /(?:sk-|pk-|rk-)[a-zA-Z0-9]{20,}/,
+  /ghp_[a-zA-Z0-9]{36}/,
+  /(?:aws|gcp|azure)[_-](?:access|secret|key)/i
+];
+function isImportantLine(line) {
+  return ERROR_PATTERNS.some((p) => p.test(line)) || WARNING_PATTERNS.some((p) => p.test(line)) || COMMAND_PATTERNS.some((p) => p.test(line));
+}
+function containsSecret(line) {
+  return SECRET_LINE_PATTERNS.some((p) => p.test(line));
+}
+function redactSecretLine(line) {
+  return line.replace(
+    /((?:api[_-]?key|apikey|secret|token|password|passwd|pwd)\s*[:=]\s*)\S+/gi,
+    "$1[REDACTED]"
+  ).replace(
+    /(?:sk-|pk-|rk-)[a-zA-Z0-9]{20,}/g,
+    "[REDACTED_KEY]"
+  ).replace(
+    /ghp_[a-zA-Z0-9]{36}/g,
+    "[REDACTED_GITHUB_TOKEN]"
+  );
+}
+function reduceLogs(content, label) {
+  const tokensBefore = estimateTokens(content);
+  const lines = content.split("\n");
+  if (lines.length <= 50) {
+    const cleaned = lines.map((l) => containsSecret(l) ? redactSecretLine(l) : l).join("\n");
+    return {
+      reduced: cleaned,
+      estimatedTokensBefore: tokensBefore,
+      estimatedTokensAfter: estimateTokens(cleaned),
+      evidenceRef: createEvidenceRef("LOG_REDUCTION", "log", `Log: ${label}`, content),
+      proofImpact: "PASS",
+      reasonCodes: lines.some(containsSecret) ? ["SECRET_REDACTED_IN_LOG"] : ["SHORT_LOG_KEPT"],
+      blockedContent: false
+    };
+  }
+  const importantLines = [];
+  const repeatedCounts = /* @__PURE__ */ new Map();
+  let totalLines = lines.length;
+  let errorCount = 0;
+  let warnCount = 0;
+  let secretsRedacted = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    if (containsSecret(line)) {
+      secretsRedacted++;
+      const redacted = redactSecretLine(line);
+      if (isImportantLine(line)) {
+        importantLines.push(redacted);
+      }
+      continue;
+    }
+    if (isImportantLine(line)) {
+      if (ERROR_PATTERNS.some((p) => p.test(line))) errorCount++;
+      if (WARNING_PATTERNS.some((p) => p.test(line))) warnCount++;
+      importantLines.push(line);
+      const contextStart = Math.max(0, i - 2);
+      const contextEnd = Math.min(lines.length - 1, i + 2);
+      for (let j = contextStart; j <= contextEnd; j++) {
+        if (j !== i && lines[j].trim() && !isImportantLine(lines[j])) {
+          if (!containsSecret(lines[j])) {
+            importantLines.push(`  ${lines[j]}`);
+          }
+        }
+      }
+      continue;
+    }
+    const normalized = trimmed.replace(/\d+/g, "N").replace(/0x[a-fA-F0-9]+/g, "0xN");
+    repeatedCounts.set(normalized, (repeatedCounts.get(normalized) || 0) + 1);
+  }
+  const repeatedSummary = [];
+  for (const [pattern, count] of repeatedCounts) {
+    if (count >= 3) {
+      repeatedSummary.push(`  (${count}x) ${pattern.slice(0, 120)}`);
+    }
+  }
+  const parts = [
+    `--- Log Summary: ${label} ---`,
+    `Total lines: ${totalLines}`,
+    `Errors: ${errorCount} | Warnings: ${warnCount} | Secrets redacted: ${secretsRedacted}`,
+    "",
+    "--- Important Lines ---",
+    ...importantLines.slice(0, 100)
+  ];
+  if (repeatedSummary.length > 0) {
+    parts.push("", "--- Repeated Patterns ---", ...repeatedSummary.slice(0, 20));
+  }
+  const reduced = parts.join("\n");
+  const tokensAfter = estimateTokens(reduced);
+  const reasonCodes = ["LARGE_LOG_REDUCED"];
+  if (secretsRedacted > 0) reasonCodes.push("SECRET_REDACTED_IN_LOG");
+  if (errorCount > 0) reasonCodes.push("ERRORS_PRESERVED");
+  if (repeatedSummary.length > 0) reasonCodes.push("REPEATED_LINES_SUMMARIZED");
+  const proofImpact = errorCount > 0 && importantLines.length > 0 ? "PASS" : "DEGRADED";
+  return {
+    reduced,
+    estimatedTokensBefore: tokensBefore,
+    estimatedTokensAfter: tokensAfter,
+    evidenceRef: createEvidenceRef("LOG_REDUCTION", "log", `Log reduced: ${label}`, content),
+    proofImpact,
+    reasonCodes,
+    blockedContent: false
+  };
+}
+
+// src/avorelo/kernel/context-control/reducers/json.ts
+var MAX_ARRAY_ITEMS = 3;
+var MAX_STRING_LENGTH2 = 200;
+var MAX_DEPTH = 6;
+function truncateValue(value, depth) {
+  if (depth > MAX_DEPTH) return "[... nested beyond depth limit]";
+  if (value === null || value === void 0) return value;
+  if (typeof value === "boolean" || typeof value === "number") return value;
+  if (typeof value === "string") {
+    if (value.length > MAX_STRING_LENGTH2) {
+      return value.slice(0, MAX_STRING_LENGTH2) + `... (${value.length} chars)`;
+    }
+    return value;
+  }
+  if (Array.isArray(value)) {
+    if (value.length === 0) return [];
+    const truncated = value.slice(0, MAX_ARRAY_ITEMS).map((v) => truncateValue(v, depth + 1));
+    if (value.length > MAX_ARRAY_ITEMS) {
+      truncated.push(`... (${value.length - MAX_ARRAY_ITEMS} more items, ${value.length} total)`);
+    }
+    return truncated;
+  }
+  if (typeof value === "object") {
+    const obj = value;
+    const keys = Object.keys(obj);
+    const result3 = {};
+    const priorityKeys = ["error", "message", "status", "code", "name", "type", "id", "path"];
+    const sortedKeys = [
+      ...priorityKeys.filter((k) => keys.includes(k)),
+      ...keys.filter((k) => !priorityKeys.includes(k))
+    ];
+    for (const key of sortedKeys) {
+      result3[key] = truncateValue(obj[key], depth + 1);
+    }
+    return result3;
+  }
+  return String(value);
+}
+function reduceJson(content, label) {
+  const tokensBefore = estimateTokens(content);
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    const fallback = content.slice(0, 2e3) + (content.length > 2e3 ? `
+... (${content.length} chars total, malformed JSON)` : "");
+    return {
+      reduced: fallback,
+      estimatedTokensBefore: tokensBefore,
+      estimatedTokensAfter: estimateTokens(fallback),
+      evidenceRef: createEvidenceRef("JSON_REDUCTION", "json_tool_output", `JSON fallback: ${label}`, content),
+      proofImpact: "DEGRADED",
+      reasonCodes: ["MALFORMED_JSON_TRUNCATED"],
+      blockedContent: false
+    };
+  }
+  const truncated = truncateValue(parsed, 0);
+  const reduced = JSON.stringify(truncated, null, 2);
+  const tokensAfter = estimateTokens(reduced);
+  const reasonCodes = ["JSON_STRUCTURE_PRESERVED"];
+  if (tokensAfter < tokensBefore * 0.8) {
+    reasonCodes.push("JSON_ARRAYS_TRUNCATED");
+  }
+  return {
+    reduced,
+    estimatedTokensBefore: tokensBefore,
+    estimatedTokensAfter: tokensAfter,
+    evidenceRef: createEvidenceRef("JSON_REDUCTION", "json_tool_output", `JSON reduced: ${label}`, content),
+    proofImpact: "PASS",
+    reasonCodes,
+    blockedContent: false
+  };
+}
+
+// src/avorelo/kernel/context-control/reducers/file-tree.ts
+var GENERATED_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  "dist",
+  "build",
+  "out",
+  ".next",
+  ".nuxt",
+  ".output",
+  "coverage",
+  ".nyc_output",
+  "__pycache__",
+  ".pytest_cache",
+  ".git",
+  ".svn",
+  ".hg",
+  "vendor",
+  "bower_components",
+  ".cache",
+  ".parcel-cache",
+  ".turbo",
+  "target",
+  "bin",
+  "obj",
+  ".terraform",
+  ".serverless"
+]);
+var PRIORITY_PATTERNS = [
+  /^src\//,
+  /^lib\//,
+  /^app\//,
+  /^pages\//,
+  /^components\//,
+  /^tests?\//,
+  /^__tests__\//,
+  /^spec\//,
+  /^scripts?\//,
+  /^config/,
+  /^\.(?:env|eslint|prettier|babel|jest|vitest)/,
+  /(?:package|tsconfig|webpack|vite|rollup)\.(?:json|config|js|ts|mjs|cjs)$/,
+  /(?:README|CHANGELOG|LICENSE|CLAUDE|AGENTS|CONTRIBUTING)\b/i,
+  /^docs?\//
+];
+function isPriority(path) {
+  return PRIORITY_PATTERNS.some((p) => p.test(path));
+}
+function isGeneratedDir(segment) {
+  return GENERATED_DIRS.has(segment.toLowerCase());
+}
+function reduceFileTree(content, label) {
+  const tokensBefore = estimateTokens(content);
+  const lines = content.split("\n").filter((l) => l.trim());
+  if (lines.length <= 100) {
+    return {
+      reduced: content,
+      estimatedTokensBefore: tokensBefore,
+      estimatedTokensAfter: tokensBefore,
+      evidenceRef: null,
+      proofImpact: "PASS",
+      reasonCodes: ["SMALL_TREE_KEPT"],
+      blockedContent: false
+    };
+  }
+  const priorityPaths = [];
+  const generatedDirs = /* @__PURE__ */ new Map();
+  const otherPaths = [];
+  for (const line of lines) {
+    const cleaned = line.replace(/^[├└│─\s│]+/, "").trim();
+    if (!cleaned) continue;
+    const firstSegment = cleaned.split("/")[0];
+    if (isGeneratedDir(firstSegment)) {
+      generatedDirs.set(firstSegment, (generatedDirs.get(firstSegment) || 0) + 1);
+      continue;
+    }
+    if (isPriority(cleaned)) {
+      priorityPaths.push(cleaned);
+    } else {
+      otherPaths.push(cleaned);
+    }
+  }
+  const parts = [
+    `--- File Tree Summary: ${label} ---`,
+    `Total entries: ${lines.length}`,
+    "",
+    "--- Source & Config (priority) ---",
+    ...priorityPaths.slice(0, 80)
+  ];
+  if (otherPaths.length > 0) {
+    parts.push("", `--- Other (${otherPaths.length} entries) ---`);
+    parts.push(...otherPaths.slice(0, 30));
+    if (otherPaths.length > 30) {
+      parts.push(`  ... (${otherPaths.length - 30} more)`);
+    }
+  }
+  if (generatedDirs.size > 0) {
+    parts.push("", "--- Generated/Vendor (summarized) ---");
+    for (const [dir, count] of generatedDirs) {
+      parts.push(`  ${dir}/ (${count} entries)`);
+    }
+  }
+  const reduced = parts.join("\n");
+  return {
+    reduced,
+    estimatedTokensBefore: tokensBefore,
+    estimatedTokensAfter: estimateTokens(reduced),
+    evidenceRef: createEvidenceRef("FILE_TREE_REDUCTION", "file_tree", `Tree reduced: ${label}`, content),
+    proofImpact: "PASS",
+    reasonCodes: ["FILE_TREE_SUMMARIZED", "GENERATED_DIRS_COLLAPSED"],
+    blockedContent: false
+  };
+}
+
+// src/avorelo/kernel/context-control/reducers/test-output.ts
+var FAIL_PATTERNS = [
+  /\b(?:FAIL|FAILED|FAILURE)\b/i,
+  /✗|✘|×|❌/,
+  /\bnot ok\b/i,
+  /AssertionError/i,
+  /\bExpected\b.*\bReceived\b/i,
+  /\bexpected\b.*\bto (?:equal|be|match|include|have)\b/i,
+  /Error:\s/,
+  /\bat\s+\S+\s+\(/
+];
+var PASS_PATTERNS = [
+  /\b(?:PASS|PASSED|OK)\b/i,
+  /✓|✔|✅/,
+  /\bok\b/i
+];
+var SUMMARY_PATTERNS = [
+  /Tests?:\s*\d+/i,
+  /Suites?:\s*\d+/i,
+  /\d+\s+(?:passing|failing|pending|skipped)/i,
+  /Test Files\s/i,
+  /Duration[:\s]/i,
+  /Time:\s/i,
+  /Ran all test suites/i
+];
+var COMMAND_PATTERNS2 = [
+  /^\$\s+/,
+  /^>\s+/,
+  /^Running\s+/i,
+  /^Executing\s+/i,
+  /^npm\s+(?:run|test)/i,
+  /^node\s+/,
+  /^npx\s+/
+];
+function reduceTestOutput(content, label) {
+  const tokensBefore = estimateTokens(content);
+  const lines = content.split("\n");
+  if (lines.length <= 80) {
+    return {
+      reduced: content,
+      estimatedTokensBefore: tokensBefore,
+      estimatedTokensAfter: tokensBefore,
+      evidenceRef: createEvidenceRef("TEST_OUTPUT_REDUCTION", "test_output", `Test output: ${label}`, content),
+      proofImpact: "PASS",
+      reasonCodes: ["SHORT_TEST_OUTPUT_KEPT"],
+      blockedContent: false
+    };
+  }
+  const failingLines = [];
+  const summaryLines = [];
+  const commandLines = [];
+  let passingCount = 0;
+  let failingCount = 0;
+  let inFailBlock = false;
+  let failBlockLines = 0;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (COMMAND_PATTERNS2.some((p) => p.test(line))) {
+      commandLines.push(line);
+      continue;
+    }
+    if (SUMMARY_PATTERNS.some((p) => p.test(line))) {
+      summaryLines.push(line);
+      continue;
+    }
+    if (FAIL_PATTERNS.some((p) => p.test(line))) {
+      inFailBlock = true;
+      failBlockLines = 0;
+      failingCount++;
+      failingLines.push(line);
+      continue;
+    }
+    if (inFailBlock && failBlockLines < 15) {
+      failBlockLines++;
+      failingLines.push(line);
+      if (line.trim() === "" || failBlockLines >= 15) {
+        inFailBlock = false;
+      }
+      continue;
+    }
+    if (PASS_PATTERNS.some((p) => p.test(line))) {
+      passingCount++;
+      inFailBlock = false;
+      continue;
+    }
+    inFailBlock = false;
+  }
+  const parts = [
+    `--- Test Output Summary: ${label} ---`
+  ];
+  if (commandLines.length > 0) {
+    parts.push("Command: " + commandLines[0]);
+  }
+  parts.push(`Passing: ${passingCount} | Failing: ${failingCount}`);
+  if (failingLines.length > 0) {
+    parts.push("", "--- Failing Tests ---");
+    parts.push(...failingLines.slice(0, 200));
+  }
+  if (summaryLines.length > 0) {
+    parts.push("", "--- Summary ---");
+    parts.push(...summaryLines);
+  }
+  if (failingCount === 0 && passingCount > 0) {
+    parts.push("", "All tests passing.");
+  }
+  const reduced = parts.join("\n");
+  const proofImpact = failingCount > 0 && failingLines.length > 0 ? "PASS" : failingCount > 0 ? "DEGRADED" : "PASS";
+  return {
+    reduced,
+    estimatedTokensBefore: tokensBefore,
+    estimatedTokensAfter: estimateTokens(reduced),
+    evidenceRef: createEvidenceRef("TEST_OUTPUT_REDUCTION", "test_output", `Tests reduced: ${label}`, content),
+    proofImpact,
+    reasonCodes: [
+      "TEST_OUTPUT_REDUCED",
+      ...failingCount > 0 ? ["FAILING_TESTS_PRESERVED"] : ["ALL_TESTS_PASSING"],
+      ...passingCount > 10 ? ["PASSING_TESTS_SUMMARIZED"] : []
+    ],
+    blockedContent: false
+  };
+}
+
+// src/avorelo/kernel/context-control/reducers/diff-summary.ts
+var GENERATED_FILE_PATTERNS = [
+  /package-lock\.json$/,
+  /yarn\.lock$/,
+  /pnpm-lock\.yaml$/,
+  /\.min\.\w+$/,
+  /\.map$/,
+  /dist\//,
+  /build\//,
+  /\.generated\./,
+  /node_modules\//
+];
+function isGeneratedFile(path) {
+  return GENERATED_FILE_PATTERNS.some((p) => p.test(path));
+}
+function reduceDiffSummary(content, label) {
+  const tokensBefore = estimateTokens(content);
+  const lines = content.split("\n");
+  const fileChanges = [];
+  let totalInsertions = 0;
+  let totalDeletions = 0;
+  let currentFile = null;
+  let currentInsertions = 0;
+  let currentDeletions = 0;
+  for (const line of lines) {
+    const diffGit = line.match(/^diff --git a\/(.+?) b\//);
+    if (diffGit) {
+      if (currentFile) {
+        fileChanges.push({
+          path: currentFile,
+          insertions: currentInsertions,
+          deletions: currentDeletions,
+          isGenerated: isGeneratedFile(currentFile)
+        });
+        totalInsertions += currentInsertions;
+        totalDeletions += currentDeletions;
+      }
+      currentFile = diffGit[1];
+      currentInsertions = 0;
+      currentDeletions = 0;
+      continue;
+    }
+    if (line.startsWith("+") && !line.startsWith("+++")) currentInsertions++;
+    if (line.startsWith("-") && !line.startsWith("---")) currentDeletions++;
+  }
+  if (currentFile) {
+    fileChanges.push({
+      path: currentFile,
+      insertions: currentInsertions,
+      deletions: currentDeletions,
+      isGenerated: isGeneratedFile(currentFile)
+    });
+    totalInsertions += currentInsertions;
+    totalDeletions += currentDeletions;
+  }
+  if (fileChanges.length === 0) {
+    const statLine = lines.find((l) => /\d+ files? changed/.test(l));
+    if (statLine) {
+      return {
+        reduced: `--- Diff Summary: ${label} ---
+${statLine}`,
+        estimatedTokensBefore: tokensBefore,
+        estimatedTokensAfter: estimateTokens(statLine),
+        evidenceRef: createEvidenceRef("DIFF_SUMMARY", "diff", `Diff stats: ${label}`, content),
+        proofImpact: "PASS",
+        reasonCodes: ["DIFF_STAT_ONLY"],
+        blockedContent: false
+      };
+    }
+    return {
+      reduced: `--- Diff Summary: ${label} ---
+No parseable diff content.`,
+      estimatedTokensBefore: tokensBefore,
+      estimatedTokensAfter: 10,
+      evidenceRef: createEvidenceRef("DIFF_SUMMARY", "diff", `Diff empty: ${label}`, content),
+      proofImpact: "UNKNOWN",
+      reasonCodes: ["DIFF_NOT_PARSEABLE"],
+      blockedContent: false
+    };
+  }
+  const sourceFiles = fileChanges.filter((f) => !f.isGenerated);
+  const generatedFiles = fileChanges.filter((f) => f.isGenerated);
+  const riskMarkers = [];
+  for (const f of sourceFiles) {
+    if (/(?:auth|security|secret|credential|password|token)/i.test(f.path)) riskMarkers.push(`SECURITY_RELATED: ${f.path}`);
+    if (/(?:migration|schema|database)/i.test(f.path)) riskMarkers.push(`MIGRATION: ${f.path}`);
+    if (/(?:deploy|prod|release|ci|cd)/i.test(f.path)) riskMarkers.push(`DEPLOYMENT: ${f.path}`);
+  }
+  const parts = [
+    `--- Diff Summary: ${label} ---`,
+    `Files changed: ${fileChanges.length} (${sourceFiles.length} source, ${generatedFiles.length} generated)`,
+    `Insertions: +${totalInsertions} | Deletions: -${totalDeletions}`
+  ];
+  if (riskMarkers.length > 0) {
+    parts.push("", "Risk markers:", ...riskMarkers.map((r2) => `  \u26A0 ${r2}`));
+  }
+  parts.push("", "Source files:");
+  for (const f of sourceFiles) {
+    parts.push(`  ${f.path} (+${f.insertions}/-${f.deletions})`);
+  }
+  if (generatedFiles.length > 0) {
+    parts.push("", `Generated files: ${generatedFiles.length} (${generatedFiles.map((f) => f.path).join(", ")})`);
+  }
+  const reduced = parts.join("\n");
+  return {
+    reduced,
+    estimatedTokensBefore: tokensBefore,
+    estimatedTokensAfter: estimateTokens(reduced),
+    evidenceRef: createEvidenceRef("DIFF_SUMMARY", "diff", `Diff summarized: ${label}`, content),
+    proofImpact: "PASS",
+    reasonCodes: ["DIFF_STATS_PRESERVED", "RAW_DIFF_NOT_PERSISTED", ...riskMarkers.length > 0 ? ["RISK_MARKERS_DETECTED"] : []],
+    blockedContent: false
+  };
+}
+
+// src/avorelo/kernel/context-control/reducers/conversation.ts
+var OBJECTIVE_PATTERNS = [
+  /\b(?:objective|goal|task|mission|purpose)\s*[:]/i,
+  /\b(?:we need to|I need to|please|implement|fix|add|create|build|update|change|remove|refactor)\b/i
+];
+var CONSTRAINT_PATTERNS = [
+  /\b(?:must not|do not|don't|never|avoid|forbidden|required|constraint|boundary|limit)\b/i,
+  /\b(?:before|after|unless|only if|except)\b/i
+];
+var DECISION_PATTERNS = [
+  /\b(?:decided|decision|chose|chosen|agreed|confirmed|approved|rejected|accepted)\b/i,
+  /\b(?:we'll|we will|let's|approach|strategy|plan is)\b/i
+];
+var UNRESOLVED_PATTERNS = [
+  /\b(?:TODO|FIXME|HACK|QUESTION|TBD|unclear|not sure|need to figure|open question)\b/i,
+  /\?\s*$/
+];
+var STATUS_PATTERNS = [
+  /\b(?:verified|tested|confirmed|working|broken|failing|passed|deployed|merged)\b/i,
+  /\b(?:status|result|outcome|state)\s*[:]/i
+];
+var NOISE_PATTERNS = [
+  /^(?:okay|ok|sure|yes|no|thanks|thank you|got it|understood|right|exactly|perfect)[\.\!\s]*$/i,
+  /^(?:let me|I'll|I will)\s+(?:check|look|see|read|examine)/i,
+  /^(?:here's|here is)\s+(?:the|what)/i,
+  /^(?:great|good|nice|excellent|awesome)/i
+];
+function isNoise(line) {
+  const trimmed = line.trim();
+  if (!trimmed) return true;
+  return NOISE_PATTERNS.some((p) => p.test(trimmed));
+}
+function matchesAny(line, patterns) {
+  return patterns.some((p) => p.test(line));
+}
+function reduceConversation(content, label) {
+  const tokensBefore = estimateTokens(content);
+  const lines = content.split("\n");
+  if (lines.length <= 60) {
+    return {
+      reduced: content,
+      estimatedTokensBefore: tokensBefore,
+      estimatedTokensAfter: tokensBefore,
+      evidenceRef: createEvidenceRef("CONVERSATION_STATE_SUMMARY", "conversation_history", `Conversation: ${label}`, content),
+      proofImpact: "PASS",
+      reasonCodes: ["SHORT_CONVERSATION_KEPT"],
+      blockedContent: false
+    };
+  }
+  const objectives = [];
+  const constraints = [];
+  const decisions = [];
+  const unresolved = [];
+  const statusUpdates = [];
+  let noiseRemoved = 0;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    if (isNoise(trimmed)) {
+      noiseRemoved++;
+      continue;
+    }
+    if (matchesAny(trimmed, OBJECTIVE_PATTERNS)) objectives.push(trimmed);
+    else if (matchesAny(trimmed, CONSTRAINT_PATTERNS)) constraints.push(trimmed);
+    else if (matchesAny(trimmed, DECISION_PATTERNS)) decisions.push(trimmed);
+    else if (matchesAny(trimmed, UNRESOLVED_PATTERNS)) unresolved.push(trimmed);
+    else if (matchesAny(trimmed, STATUS_PATTERNS)) statusUpdates.push(trimmed);
+  }
+  const parts = [`--- Conversation Summary: ${label} ---`];
+  if (objectives.length > 0) {
+    parts.push("", "Objectives:", ...objectives.slice(0, 10).map((o) => `  - ${o.slice(0, 200)}`));
+  }
+  if (constraints.length > 0) {
+    parts.push("", "Constraints:", ...constraints.slice(0, 10).map((c) => `  - ${c.slice(0, 200)}`));
+  }
+  if (decisions.length > 0) {
+    parts.push("", "Decisions:", ...decisions.slice(0, 10).map((d) => `  - ${d.slice(0, 200)}`));
+  }
+  if (unresolved.length > 0) {
+    parts.push("", "Unresolved:", ...unresolved.slice(0, 10).map((u) => `  - ${u.slice(0, 200)}`));
+  }
+  if (statusUpdates.length > 0) {
+    parts.push("", "Latest status:", ...statusUpdates.slice(-5).map((s) => `  - ${s.slice(0, 200)}`));
+  }
+  parts.push("", `Noise removed: ${noiseRemoved} lines`);
+  const reduced = parts.join("\n");
+  return {
+    reduced,
+    estimatedTokensBefore: tokensBefore,
+    estimatedTokensAfter: estimateTokens(reduced),
+    evidenceRef: createEvidenceRef("CONVERSATION_STATE_SUMMARY", "conversation_history", `Conversation reduced: ${label}`, content),
+    proofImpact: objectives.length > 0 || decisions.length > 0 ? "PASS" : "DEGRADED",
+    reasonCodes: [
+      "CONVERSATION_SUMMARIZED",
+      ...noiseRemoved > 0 ? ["NOISE_REMOVED"] : [],
+      ...objectives.length > 0 ? ["OBJECTIVES_PRESERVED"] : [],
+      ...decisions.length > 0 ? ["DECISIONS_PRESERVED"] : [],
+      ...unresolved.length > 0 ? ["UNRESOLVED_FLAGGED"] : []
+    ],
+    blockedContent: false
+  };
+}
+
+// src/avorelo/kernel/context-control/cache-align.ts
+function analyzeCacheAlignment(items) {
+  let stableCount = 0;
+  let semiStableCount = 0;
+  let volatileCount = 0;
+  const invalidationReasons = [];
+  for (const item2 of items) {
+    const contentType = classifyContentType(item2.content, item2.label);
+    const volatility = classifyVolatility(contentType);
+    switch (volatility) {
+      case "stable":
+        stableCount++;
+        break;
+      case "semi_stable":
+        semiStableCount++;
+        break;
+      case "volatile":
+        volatileCount++;
+        break;
+    }
+  }
+  const totalItems = items.length;
+  const cacheBreakRisk = totalItems > 0 && volatileCount > stableCount;
+  if (stableCount === 0 && totalItems > 0) {
+    invalidationReasons.push("NO_STABLE_CONTEXT_BLOCKS");
+  }
+  if (volatileCount > stableCount * 2) {
+    invalidationReasons.push("VOLATILE_DOMINATES_STABLE");
+  }
+  if (totalItems > 20) {
+    invalidationReasons.push("HIGH_ITEM_COUNT_MAY_FRAGMENT_CACHE");
+  }
+  const layout = [];
+  if (stableCount > 0) layout.push("1. System/product contract (stable)");
+  if (stableCount > 0) layout.push("2. Project facts & conventions (stable)");
+  if (semiStableCount > 0) layout.push("3. Repo map & dependencies (semi-stable)");
+  if (volatileCount > 0) layout.push("4. Current task & tool output (volatile)");
+  return {
+    stableBlockCount: stableCount,
+    semiStableBlockCount: semiStableCount,
+    volatileBlockCount: volatileCount,
+    cacheStablePrefixAvailable: stableCount > 0,
+    cacheBreakRisk,
+    cacheInvalidationReasons: invalidationReasons,
+    suggestedPromptLayout: layout
+  };
+}
+
+// src/avorelo/kernel/context-control/diagnostics.ts
+function generateDiagnostics(result3) {
+  const diagnostics = [];
+  if (result3.blockedItemsCount > 0) {
+    diagnostics.push({
+      severity: "warning",
+      code: "CONTEXT_ITEMS_BLOCKED",
+      message: `${result3.blockedItemsCount} context item(s) were blocked due to forbidden or secret-like content.`,
+      remediation: "Review blocked items and redact sensitive content before including in context.",
+      safeForReceipt: true
+    });
+  }
+  if (result3.proofImpact === "DEGRADED") {
+    diagnostics.push({
+      severity: "warning",
+      code: "PROOF_IMPACT_DEGRADED",
+      message: "Context compression may have removed proof-critical evidence.",
+      remediation: "Rerun with evidence retrieval or use manual review to verify proof chain.",
+      safeForReceipt: true
+    });
+  }
+  if (result3.proofImpact === "UNKNOWN") {
+    diagnostics.push({
+      severity: "blocker",
+      code: "PROOF_IMPACT_UNKNOWN",
+      message: "Unable to determine proof impact of context compression.",
+      remediation: "Review original context to determine if proof-critical evidence was affected.",
+      safeForReceipt: true
+    });
+  }
+  if (result3.compressionRatio > 0.95) {
+    diagnostics.push({
+      severity: "info",
+      code: "HIGH_COMPRESSION_RATIO",
+      message: `Context was compressed by ${Math.round(result3.compressionRatio * 100)}%. Verify that important context was preserved.`,
+      remediation: "Check evidence refs to confirm key information is retrievable.",
+      safeForReceipt: true
+    });
+  }
+  if (result3.cacheAlignment.cacheBreakRisk) {
+    diagnostics.push({
+      severity: "info",
+      code: "CACHE_BREAK_RISK",
+      message: "Volatile context blocks outnumber stable blocks, reducing cache effectiveness.",
+      remediation: "Move stable project context (system prompt, conventions) to the front of the prompt.",
+      safeForReceipt: true
+    });
+  }
+  if (!result3.cacheAlignment.cacheStablePrefixAvailable) {
+    diagnostics.push({
+      severity: "info",
+      code: "NO_STABLE_PREFIX",
+      message: "No stable context prefix detected. Provider prompt caching will be less effective.",
+      remediation: "Add stable system/project context blocks at the beginning of the prompt.",
+      safeForReceipt: true
+    });
+  }
+  if (result3.estimatedInputTokensBefore > 1e5) {
+    diagnostics.push({
+      severity: "warning",
+      code: "VERY_LARGE_CONTEXT",
+      message: `Input context estimated at ${result3.estimatedInputTokensBefore.toLocaleString()} tokens before reduction.`,
+      remediation: "Consider narrowing task scope or excluding unnecessary context sources.",
+      safeForReceipt: true
+    });
+  }
+  if (result3.evidenceRefs.length === 0 && result3.estimatedInputTokensBefore > result3.estimatedInputTokensAfter) {
+    diagnostics.push({
+      severity: "warning",
+      code: "COMPRESSION_WITHOUT_EVIDENCE",
+      message: "Context was compressed but no evidence refs were created for recovery.",
+      remediation: "Ensure reducers create evidence refs for recoverable content.",
+      safeForReceipt: true
+    });
+  }
+  return diagnostics;
+}
+function buildReceiptSummary(result3) {
+  const reductionPercent = result3.estimatedInputTokensBefore > 0 ? Math.round((result3.estimatedInputTokensBefore - result3.estimatedInputTokensAfter) / result3.estimatedInputTokensBefore * 100) : 0;
+  let status;
+  if (result3.decision === "BLOCK_FORBIDDEN_CONTEXT") {
+    status = "BLOCKED";
+  } else if (result3.proofImpact === "DEGRADED" || result3.proofImpact === "UNKNOWN") {
+    status = "DEGRADED";
+  } else if (result3.decision === "ALLOW_AS_IS" && result3.estimatedInputTokensBefore === result3.estimatedInputTokensAfter) {
+    status = "INACTIVE";
+  } else {
+    status = "ACTIVE";
+  }
+  const summaryParts = [];
+  if (status === "ACTIVE") {
+    summaryParts.push(`Context reduced from ~${result3.estimatedInputTokensBefore.toLocaleString()} to ~${result3.estimatedInputTokensAfter.toLocaleString()} tokens (${reductionPercent}% reduction).`);
+  } else if (status === "BLOCKED") {
+    summaryParts.push("Context blocked due to forbidden content.");
+  } else if (status === "DEGRADED") {
+    summaryParts.push("Context compressed but proof chain may be weakened.");
+  } else {
+    summaryParts.push("Context passed through without reduction.");
+  }
+  if (result3.evidenceRefs.length > 0) {
+    summaryParts.push(`${result3.evidenceRefs.length} evidence ref(s) available for retrieval.`);
+  }
+  return {
+    contextControlStatus: status,
+    estimatedContextBefore: result3.estimatedInputTokensBefore,
+    estimatedContextSent: result3.estimatedInputTokensAfter,
+    reductionPercent,
+    evidenceRefCount: result3.evidenceRefs.length,
+    blockedItemsCount: result3.blockedItemsCount,
+    retrievalAvailable: result3.evidenceRefs.some((r2) => r2.retrievalPolicy === "available"),
+    proofImpact: result3.proofImpact,
+    topReasonCodes: result3.reasonCodes.slice(0, 5),
+    summary: summaryParts.join(" ")
+  };
+}
+function renderContextStats(summary) {
+  const lines = [
+    `Context Control: ${summary.contextControlStatus}`,
+    `Estimated context before: ${summary.estimatedContextBefore.toLocaleString()} tokens`,
+    `Estimated context sent: ${summary.estimatedContextSent.toLocaleString()} tokens`,
+    `Reduction: ${summary.reductionPercent}%`,
+    `Evidence refs: ${summary.evidenceRefCount}`,
+    `Blocked items: ${summary.blockedItemsCount}`,
+    `Retrieval available: ${summary.retrievalAvailable ? "yes" : "no"}`,
+    `Proof impact: ${summary.proofImpact}`
+  ];
+  if (summary.topReasonCodes.length > 0) {
+    lines.push(`Top reasons: ${summary.topReasonCodes.join(", ")}`);
+  }
+  return lines.join("\n");
+}
+function renderContextExplain(summary, diagnostics) {
+  const parts = [
+    renderContextStats(summary),
+    "",
+    "--- Explanation ---",
+    summary.summary
+  ];
+  if (diagnostics.length > 0) {
+    parts.push("", "--- Diagnostics ---");
+    for (const d of diagnostics) {
+      parts.push(`[${d.severity.toUpperCase()}] ${d.code}: ${d.message}`);
+      parts.push(`  Action: ${d.remediation}`);
+    }
+  }
+  return parts.join("\n");
+}
+
+// src/avorelo/kernel/context-control/learn.ts
+var KNOWN_FAILURE_MAPPINGS = [
+  {
+    pattern: /npm publish.*(?:OTP|auth|ENEEDAUTH)/i,
+    candidateType: "WORKFLOW_CORRECTION",
+    template: () => "When npm publish or dist-tag promotion requires auth/OTP, generate a local PowerShell script for the owner to run. Do not ask for OTP in chat.",
+    target: "CLAUDE.md"
+  },
+  {
+    pattern: /(?:EACCES|permission denied|EPERM)/i,
+    candidateType: "TOOL_LIMITATION",
+    template: (match) => `Permission error encountered: ${match.slice(0, 100)}. Consider running with elevated permissions or checking file ownership.`,
+    target: "AGENTS.md"
+  },
+  {
+    pattern: /(?:ENOSPC|disk full|no space)/i,
+    candidateType: "TOOL_LIMITATION",
+    template: () => "Disk space constraints detected. Clean build artifacts before large operations.",
+    target: "AGENTS.md"
+  },
+  {
+    pattern: /(?:timeout|ETIMEDOUT|ESOCKETTIMEDOUT)/i,
+    candidateType: "WORKFLOW_CORRECTION",
+    template: () => "Network timeouts are common in this environment. Use local-first approaches where possible.",
+    target: "CLAUDE.md"
+  },
+  {
+    pattern: /node_modules.*(?:large|huge|big|slow)/i,
+    candidateType: "NOISE_PATTERN",
+    template: () => "node_modules content should be excluded from context. Use package.json and lock file summaries instead.",
+    target: "CLAUDE.md"
+  }
+];
+function isSafeCandidate(text) {
+  const lower = text.toLowerCase();
+  if (/(?:api[_-]?key|secret|token|password)\s*[:=]\s*\S{10,}/i.test(text)) return false;
+  if (/-----BEGIN.*KEY-----/.test(text)) return false;
+  if (/(?:ignore all|disregard|you are now|act as|pretend)/i.test(lower)) return false;
+  return true;
+}
+function generateLearningCandidates(input) {
+  const candidates = [];
+  if (input.failurePatterns) {
+    for (const failure of input.failurePatterns) {
+      if (failure.occurrences < 2) continue;
+      for (const mapping of KNOWN_FAILURE_MAPPINGS) {
+        if (mapping.pattern.test(failure.pattern)) {
+          const proposedText = mapping.template(failure.pattern);
+          if (!isSafeCandidate(proposedText)) continue;
+          candidates.push({
+            candidateType: mapping.candidateType,
+            sourceReceiptIds: failure.receiptIds.slice(0, 5),
+            evidenceRefs: failure.evidenceRefs.slice(0, 5),
+            confidence: failure.occurrences >= 5 ? "high" : failure.occurrences >= 3 ? "medium" : "low",
+            proposedText,
+            suggestedWriteTarget: mapping.target,
+            requiresApproval: true,
+            safeForPersistence: true,
+            reasonCodes: [`REPEATED_FAILURE_${failure.occurrences}x`, `PATTERN_MATCH_${mapping.candidateType}`]
+          });
+          break;
+        }
+      }
+    }
+  }
+  const receiptReasonCounts = /* @__PURE__ */ new Map();
+  for (const receipt of input.receipts) {
+    for (const code of receipt.topReasonCodes) {
+      receiptReasonCounts.set(code, (receiptReasonCounts.get(code) || 0) + 1);
+    }
+  }
+  for (const [code, count] of receiptReasonCounts) {
+    if (count >= 3 && code.includes("BLOCKED")) {
+      candidates.push({
+        candidateType: "SAFETY_RULE",
+        sourceReceiptIds: [],
+        evidenceRefs: [],
+        confidence: "medium",
+        proposedText: `Frequently blocked context pattern: ${code}. Review whether this pattern should be allowlisted or permanently blocked.`,
+        suggestedWriteTarget: "CLAUDE.md",
+        requiresApproval: true,
+        safeForPersistence: true,
+        reasonCodes: [`FREQUENT_BLOCK_${count}x`, code]
+      });
+    }
+  }
+  return {
+    candidates,
+    dryRun: true,
+    filesWritten: 0,
+    summary: candidates.length > 0 ? `Generated ${candidates.length} learning candidate(s). All require explicit approval before writing.` : "No learning candidates generated from current evidence."
+  };
+}
+
+// src/avorelo/kernel/context-control/index.ts
+function selectReducer(item2) {
+  const classification = item2.classification ?? classifyItem(item2);
+  switch (classification.contentType) {
+    case "log":
+      return reduceLogs;
+    case "json_tool_output":
+      return reduceJson;
+    case "file_tree":
+      return reduceFileTree;
+    case "test_output":
+      return reduceTestOutput;
+    case "diff":
+      return reduceDiffSummary;
+    case "conversation_history":
+      return reduceConversation;
+    default:
+      return null;
+  }
+}
+function isForbidden(item2, input) {
+  if (containsForbiddenContent(item2.content)) return true;
+  if (input.forbiddenContext) {
+    for (const pattern of input.forbiddenContext) {
+      if (item2.label.includes(pattern) || item2.content.includes(pattern)) return true;
+    }
+  }
+  return false;
+}
+function isAllowed(item2, input) {
+  if (!input.allowedContext || input.allowedContext.length === 0) return true;
+  return input.allowedContext.some((a) => item2.label.includes(a) || item2.content.includes(a));
+}
+function needsManualApproval(item2, input) {
+  if (input.riskLevel === "critical") return true;
+  const classification = item2.classification ?? classifyItem(item2);
+  if (classification.sensitivity === "secret_like" && input.redactionPolicy === "strict") return true;
+  return false;
+}
+function processContextControl(input) {
+  const classifiedItems = input.items.map((item2) => ({
+    ...item2,
+    classification: item2.classification ?? classifyItem(item2)
+  }));
+  const totalTokensBefore = classifiedItems.reduce((sum, item2) => sum + item2.classification.estimatedTokens, 0);
+  const reducedParts = [];
+  const evidenceRefs = [];
+  const reasonCodes = [];
+  const learningSignals = [];
+  let blockedCount = 0;
+  let overallProofImpact = "PASS";
+  let overallDecision = "ALLOW_AS_IS";
+  let overallReductionKind = "NONE";
+  let anyReduced = false;
+  let anyBlocked = false;
+  for (const item2 of classifiedItems) {
+    if (isForbidden(item2, input)) {
+      blockedCount++;
+      anyBlocked = true;
+      evidenceRefs.push(createBlockedEvidenceRef(item2.classification.contentType, `Forbidden: ${item2.label}`));
+      reasonCodes.push("FORBIDDEN_CONTEXT_BLOCKED");
+      continue;
+    }
+    if (!isAllowed(item2, input)) {
+      blockedCount++;
+      evidenceRefs.push(createBlockedEvidenceRef(item2.classification.contentType, `Not in allowlist: ${item2.label}`));
+      reasonCodes.push("CONTEXT_NOT_IN_ALLOWLIST");
+      continue;
+    }
+    if (needsManualApproval(item2, input)) {
+      blockedCount++;
+      evidenceRefs.push(createBlockedEvidenceRef(item2.classification.contentType, `Requires approval: ${item2.label}`));
+      reasonCodes.push("MANUAL_APPROVAL_REQUIRED");
+      continue;
+    }
+    if (containsSecrets(item2.content)) {
+      blockedCount++;
+      anyBlocked = true;
+      evidenceRefs.push(createBlockedEvidenceRef(item2.classification.contentType, `Secret-like content: ${item2.label}`));
+      reasonCodes.push("SECRET_LIKE_CONTEXT_BLOCKED");
+      continue;
+    }
+    const reducer = selectReducer(item2);
+    if (reducer && item2.classification.estimatedTokens > 200) {
+      const result3 = reducer(item2.content, item2.label);
+      reducedParts.push(result3.reduced);
+      if (result3.evidenceRef) evidenceRefs.push(result3.evidenceRef);
+      reasonCodes.push(...result3.reasonCodes);
+      anyReduced = true;
+      if (result3.proofImpact === "DEGRADED") overallProofImpact = "DEGRADED";
+      if (result3.proofImpact === "UNKNOWN" && overallProofImpact !== "DEGRADED") overallProofImpact = "UNKNOWN";
+    } else {
+      reducedParts.push(item2.content);
+    }
+  }
+  const reducedContent = reducedParts.join("\n\n");
+  const totalTokensAfter = estimateTokens(reducedContent);
+  if (anyBlocked && blockedCount === classifiedItems.length) {
+    overallDecision = "BLOCK_FORBIDDEN_CONTEXT";
+    overallReductionKind = "BLOCKED";
+  } else if (anyBlocked) {
+    overallDecision = "COMPRESS_WITH_EVIDENCE";
+    overallReductionKind = "BLOCKED";
+  } else if (anyReduced) {
+    overallDecision = "COMPRESS_WITH_EVIDENCE";
+    const dominantType = classifiedItems.filter((i) => !isForbidden(i, input)).sort((a, b) => b.classification.estimatedTokens - a.classification.estimatedTokens)[0];
+    if (dominantType) {
+      const typeToKind = {
+        log: "LOG_REDUCTION",
+        json_tool_output: "JSON_REDUCTION",
+        file_tree: "FILE_TREE_REDUCTION",
+        test_output: "TEST_OUTPUT_REDUCTION",
+        diff: "DIFF_SUMMARY",
+        conversation_history: "CONVERSATION_STATE_SUMMARY"
+      };
+      overallReductionKind = typeToKind[dominantType.classification.contentType] ?? "NONE";
+    }
+  }
+  if (totalTokensAfter > input.contextBudget) {
+    reasonCodes.push("CONTEXT_EXCEEDS_BUDGET");
+    if (overallDecision === "ALLOW_AS_IS") overallDecision = "ASK_FOR_NARROWER_SCOPE";
+  }
+  const compressionRatio = totalTokensBefore > 0 ? (totalTokensBefore - totalTokensAfter) / totalTokensBefore : 0;
+  const deduplicatedReasonCodes = [...new Set(reasonCodes)];
+  const cacheAlignment = analyzeCacheAlignment(classifiedItems);
+  const partialResult = {
+    decision: overallDecision,
+    reductionKind: overallReductionKind,
+    reasonCodes: deduplicatedReasonCodes,
+    riskLevel: input.riskLevel ?? "low",
+    safeForModel: !anyBlocked || blockedCount < classifiedItems.length,
+    safeForPersistence: !deduplicatedReasonCodes.includes("SECRET_LIKE_CONTEXT_BLOCKED"),
+    estimatedInputTokensBefore: totalTokensBefore,
+    estimatedInputTokensAfter: totalTokensAfter,
+    compressionRatio,
+    evidenceRefs,
+    blockedItemsCount: blockedCount,
+    retrievalAvailable: evidenceRefs.some((r2) => r2.retrievalPolicy === "available"),
+    proofImpact: overallProofImpact,
+    receiptSafeSummary: null,
+    diagnostics: [],
+    cacheAlignment,
+    learningSignals,
+    reducedContent
+  };
+  partialResult.diagnostics = generateDiagnostics(partialResult);
+  partialResult.receiptSafeSummary = buildReceiptSummary(partialResult);
+  return partialResult;
+}
+
 // src/avorelo/capabilities/runtime-flow/index.ts
 init_redaction();
 function runtimeDir(dir) {
@@ -11510,7 +12787,7 @@ function safeFallbackProjection(reasonCodes, extraVerifierPlan = []) {
   };
 }
 function freshRuntimeId(seed) {
-  return "rts_" + createHash12("sha256").update(seed).digest("hex").slice(0, 12);
+  return "rts_" + createHash13("sha256").update(seed).digest("hex").slice(0, 12);
 }
 function coded(text) {
   try {
@@ -11860,6 +13137,54 @@ function runRuntimeSession(input) {
   } catch {
     base.contextPack = void 0;
   }
+  try {
+    if (compiledContextPacket) {
+      const ccItems = compiledContextPacket.selectedRefs.map((ref2, i) => ({
+        id: `cc_${i}`,
+        label: ref2.label,
+        content: `[${ref2.kind}] ${ref2.label} (${ref2.includeMode}/${ref2.safety})`
+      }));
+      const forbiddenLabels = compiledContextPacket.excludedRefs.map((r2) => r2.label);
+      const budgetMap = { tiny: 4e3, small: 16e3, medium: 5e4, deep: 12e4 };
+      const ccResult = processContextControl({
+        consumerRole: "executor",
+        items: ccItems,
+        contextBudget: budgetMap[compiledContextPacket.contextBudget.targetSize] ?? 5e4,
+        forbiddenContext: forbiddenLabels,
+        redactionPolicy: "standard",
+        riskLevel: c.riskClass === "critical" ? "critical" : c.riskClass
+      });
+      const summary = ccResult.receiptSafeSummary;
+      const status = summary.controlStatus;
+      const ref = (() => {
+        try {
+          const ccDir = join39(dir, ".avorelo", "context-control");
+          mkdirSync24(ccDir, { recursive: true });
+          const p = join39(ccDir, "latest.json");
+          writeFileSync23(p, JSON.stringify(summary, null, 2));
+          return p;
+        } catch {
+          return null;
+        }
+      })();
+      const detail = `status=${status} context=${summary.estimatedContextBefore}\u2192${summary.estimatedContextSent} reduction=${summary.reductionPercent}%`;
+      base.contextControl = {
+        status,
+        estimatedContextBefore: summary.estimatedContextBefore,
+        estimatedContextAfter: summary.estimatedContextSent,
+        reductionPercent: summary.reductionPercent,
+        evidenceRefCount: summary.evidenceRefCount,
+        blockedItemsCount: summary.blockedItemsCount,
+        retrievalAvailable: summary.retrievalAvailable,
+        proofImpact: summary.proofImpact,
+        reasonCodes: summary.reasonCodes,
+        ref
+      };
+      layers.push({ order: 3.5, layer: "context_control", capability: "context-control", status: "completed", ref, detail: coded(detail) });
+    }
+  } catch (e) {
+    layers.push({ order: 3.5, layer: "context_control", capability: "context-control", status: "unavailable", ref: null, detail: coded(errCode(e)) });
+  }
   if (plannedToolExecution) {
     const execCtx = {
       dir,
@@ -12402,6 +13727,18 @@ function buildControlCenter(dir, opts) {
     }
   } catch {
   }
+  const contextControlSection = runtime?.contextControl ? {
+    status: "available",
+    controlStatus: runtime.contextControl.status,
+    estimatedContextBefore: runtime.contextControl.estimatedContextBefore,
+    estimatedContextAfter: runtime.contextControl.estimatedContextAfter,
+    reductionPercent: runtime.contextControl.reductionPercent,
+    evidenceRefCount: runtime.contextControl.evidenceRefCount,
+    blockedItemsCount: runtime.contextControl.blockedItemsCount,
+    retrievalAvailable: runtime.contextControl.retrievalAvailable,
+    proofImpact: runtime.contextControl.proofImpact,
+    reasonCodes: runtime.contextControl.reasonCodes
+  } : { status: "unavailable" };
   const dash = buildLocalDashboard(dir, { now: opts.now, staleWindowMs: opts.staleWindowMs });
   const receiptsSection = {
     total: dash.totals.total,
@@ -12504,6 +13841,7 @@ function buildControlCenter(dir, opts) {
       continuity: continuitySection,
       efficiencySync: efficiencySection,
       contextCheck: contextCheckSection,
+      contextControl: contextControlSection,
       receipts: receiptsSection,
       entitlementGate: entitlementGateSection,
       modelRouting: modelRoutingSection,
@@ -12543,6 +13881,7 @@ function renderText2(m) {
   lines.push(`  Continuity:${s.continuity.status === "available" ? ` ${s.continuity.packetStatus} \xB7 ${s.continuity.safeNextActionCount} next action(s) \xB7 ${s.continuity.proofMissingCount} proof gap(s)` : " none"}`);
   lines.push(`  Sync:      ${s.efficiencySync.status === "available" ? `${s.efficiencySync.mode} \xB7 ${s.efficiencySync.eligibleCount} eligible / ${s.efficiencySync.blockedCount} blocked` : "none"}`);
   lines.push(`  Context:   ${s.contextCheck.status === "available" ? `${s.contextCheck.checkStatus} \xB7 risk=${s.contextCheck.riskLevel} \xB7 ${s.contextCheck.inputsChecked} source(s) \xB7 ${s.contextCheck.findingCount} finding(s) \xB7 policy=${s.contextCheck.policyPresent}` : "none"}`);
+  lines.push(`  Ctx ctrl:  ${s.contextControl.status === "available" ? `${s.contextControl.controlStatus} \xB7 context=${s.contextControl.estimatedContextBefore}\u2192${s.contextControl.estimatedContextAfter} \xB7 reduction=${s.contextControl.reductionPercent}% \xB7 evidence=${s.contextControl.evidenceRefCount} \xB7 blocked=${s.contextControl.blockedItemsCount} \xB7 proof=${s.contextControl.proofImpact}` : "none"}`);
   lines.push(`  Receipts:  ${s.receipts.total} \xB7 done ${s.receipts.done} \xB7 blocked ${s.receipts.blocked} \xB7 needs-attention ${s.receipts.needsAttention} \xB7 stale ${s.receipts.stale}`);
   if (s.modelRouting.status === "available") {
     lines.push(`  Routing:   primitive=${s.modelRouting.selectedPrimitive} profile=${s.modelRouting.selectedModelProfile} resolver=${s.modelRouting.resolverStatus} provider=${s.modelRouting.providerClass}`);
@@ -12622,7 +13961,7 @@ function openControlCenter(dir, opts) {
 }
 
 // src/avorelo/capabilities/activation/init.ts
-import { createHash as createHash13, randomUUID as randomUUID4 } from "node:crypto";
+import { createHash as createHash14, randomUUID as randomUUID4 } from "node:crypto";
 import { existsSync as existsSync41, mkdirSync as mkdirSync26, writeFileSync as writeFileSync25, readFileSync as readFileSync25, statSync as statSync4, accessSync, constants } from "node:fs";
 import { join as join41 } from "node:path";
 var ACTIVATION_V1_CONTRACT = "avorelo.activation.v1";
@@ -12637,7 +13976,7 @@ function activationPath(dir) {
   return join41(avoreloDir(dir), "activation.json");
 }
 function freshActivationId(seed) {
-  return "act_" + createHash13("sha256").update(seed).digest("hex").slice(0, 12);
+  return "act_" + createHash14("sha256").update(seed).digest("hex").slice(0, 12);
 }
 function loadWorkspace(dir) {
   const p = workspacePath(dir);
@@ -12842,14 +14181,14 @@ function renderDogfoodCheck(r2) {
 }
 
 // src/avorelo/capabilities/core-readiness/index.ts
-import { createHash as createHash15 } from "node:crypto";
+import { createHash as createHash16 } from "node:crypto";
 import { existsSync as existsSync43, readFileSync as readFileSync27 } from "node:fs";
 import { join as join43 } from "node:path";
 
 // src/avorelo/capabilities/canonical-readiness/index.ts
 import { existsSync as existsSync42, readFileSync as readFileSync26, readdirSync as readdirSync11, statSync as statSync5 } from "node:fs";
 import { join as join42 } from "node:path";
-import { createHash as createHash14 } from "node:crypto";
+import { createHash as createHash15 } from "node:crypto";
 var FORBIDDEN_CLAIM_PATTERNS = [
   { code: "guaranteed_savings", re: /guaranteed savings|guarantee[sd]? .{0,20}savings/ },
   { code: "zero_leak_guarantee", re: /zero[- ]leak guarantee|guarantee[sd]? .{0,20}no leak|no secret will ever leak/ },
@@ -13055,7 +14394,7 @@ function buildCanonicalReadinessReport(target, opts = {}) {
     contract: "avorelo.canonicalReadiness.v1",
     schemaVersion: 1,
     createdAt,
-    readinessId: "rdy_" + createHash14("sha256").update(`${createdAt}:${result3}:${blockers.length}`).digest("hex").slice(0, 12),
+    readinessId: "rdy_" + createHash15("sha256").update(`${createdAt}:${result3}:${blockers.length}`).digest("hex").slice(0, 12),
     result: result3,
     phaseCoverage,
     oldRepoCapabilityCoverage,
@@ -13248,7 +14587,7 @@ function buildCoreReadiness(opts) {
     contract: CORE_READINESS_CONTRACT,
     schemaVersion: 1,
     createdAt,
-    reportId: "core_" + createHash15("sha256").update(`${createdAt}:${result3}`).digest("hex").slice(0, 12),
+    reportId: "core_" + createHash16("sha256").update(`${createdAt}:${result3}`).digest("hex").slice(0, 12),
     result: result3,
     checks,
     safetyInvariants,
@@ -16085,7 +17424,7 @@ var FORBIDDEN_KEYS2 = /* @__PURE__ */ new Set([
   "rawPath",
   "settings"
 ]);
-var SECRET_PATTERNS2 = [
+var SECRET_PATTERNS3 = [
   /ghp_[A-Za-z0-9]{36}/,
   /gho_[A-Za-z0-9]{36}/,
   /github_pat_[A-Za-z0-9_]{22,}/,
@@ -16131,7 +17470,7 @@ function validateDogfoodLearningPayload(payload) {
 function inspectStringValue(val, key) {
   if (val.length > 256) return { valid: false, code: "value_too_long", detail: `${key}: ${val.length} chars` };
   if (val.includes("\n") && val.split("\n").length > 2) return { valid: false, code: "multiline_value", detail: key };
-  for (const pat of SECRET_PATTERNS2) {
+  for (const pat of SECRET_PATTERNS3) {
     if (pat.test(val)) return { valid: false, code: "secret_pattern", detail: key };
   }
   if (PATH_PATTERN.test(val) && key !== "createdAt") return { valid: false, code: "path_value", detail: key };
@@ -16425,9 +17764,9 @@ function renderPayloadPreview(p) {
 }
 
 // src/avorelo/capabilities/cloud-sync/claim-token.ts
-import { randomBytes, createHash as createHash16 } from "node:crypto";
+import { randomBytes, createHash as createHash17 } from "node:crypto";
 function generateLocalFingerprint(target) {
-  return createHash16("sha256").update(target).digest("hex").slice(0, 16);
+  return createHash17("sha256").update(target).digest("hex").slice(0, 16);
 }
 var CLAIM_EXPIRY_MS = 24 * 60 * 60 * 1e3;
 
@@ -16733,7 +18072,7 @@ function getTelemetryConfig(dir, state) {
 }
 
 // src/avorelo/telemetry/privacy.ts
-import { createHmac as createHmac2, createHash as createHash17, randomUUID as randomUUID9 } from "node:crypto";
+import { createHmac as createHmac2, createHash as createHash18, randomUUID as randomUUID9 } from "node:crypto";
 import { basename as basename4, resolve as resolve4 } from "node:path";
 var FORBIDDEN_FIELD_PATTERNS = [
   /rawprompt/i,
@@ -16892,7 +18231,7 @@ function inferAgentType(commandName) {
 function sanitizeTelemetryEvent(rawEvent, ctx) {
   const unsafeFields = detectUnsafeTelemetryFields(rawEvent);
   const excludedFields = new Set(unsafeFields);
-  const eventId = typeof rawEvent.eventId === "string" && rawEvent.eventId ? rawEvent.eventId : `evt_${createHash17("sha256").update(randomUUID9()).digest("hex").slice(0, 16)}`;
+  const eventId = typeof rawEvent.eventId === "string" && rawEvent.eventId ? rawEvent.eventId : `evt_${createHash18("sha256").update(randomUUID9()).digest("hex").slice(0, 16)}`;
   const occurredAt = typeof rawEvent.occurredAt === "string" && rawEvent.occurredAt ? rawEvent.occurredAt : (/* @__PURE__ */ new Date()).toISOString();
   const repoRoot2 = typeof rawEvent.repoRoot === "string" ? rawEvent.repoRoot : void 0;
   const remoteUrl = typeof rawEvent.remoteUrl === "string" ? rawEvent.remoteUrl : void 0;
@@ -18169,12 +19508,12 @@ function computeNextBestAction(outcome, counts) {
 }
 
 // src/avorelo/kernel/agent-artifact-guard/receipt.ts
-import { createHash as createHash18 } from "node:crypto";
+import { createHash as createHash19 } from "node:crypto";
 function createReceipt(result3) {
   return {
     receiptType: "agent-artifact-guard-v1",
     scannedAt: result3.scannedAt,
-    projectRootHash: createHash18("sha256").update(result3.projectRoot).digest("hex"),
+    projectRootHash: createHash19("sha256").update(result3.projectRoot).digest("hex"),
     filesScanned: result3.filesScanned,
     artifacts: result3.artifacts.map((a) => ({ kind: a.kind, path: a.path })),
     findingSummary: {
@@ -18882,17 +20221,22 @@ Activation taxonomy: ${preflight.taxonomy}
     lines.push("", "  Fixed:");
     for (const f of fv.fixed) lines.push(`    ${f}`);
   }
-  if (fv.needsAttention.length > 0) {
+  const blockedItems = fv.needsAttention.filter((n) => n.startsWith("Blocked:"));
+  if (blockedItems.length > 0) {
     lines.push("", "  Needs attention:");
-    for (const n of fv.needsAttention) lines.push(`    ${n}`);
+    for (const n of blockedItems) lines.push(`    ${n}`);
   }
   lines.push(
     "",
     `  Run entry:  ${state.runEntry.installed ? "installed" : "not installed"}`,
-    `  Billing:    ${state.billing.status}`,
-    `  Auth:       ${state.auth.status}`,
-    `  Production: not ready`
+    `  Agent Guard: available`,
+    `  Receipts:   working`
   );
+  const optionalItems = fv.needsAttention.filter((n) => !n.startsWith("Blocked:"));
+  if (optionalItems.length > 0) {
+    lines.push("", "  Optional (not required for local activation):");
+    for (const n of optionalItems) lines.push(`    ${n}`);
+  }
   let linkResult = "no claim provided";
   if (claimToken) {
     const baseUrl = process.env.APP_BASE_URL ?? "https://app.avorelo.com";
@@ -18983,6 +20327,14 @@ async function cmdDoctor(args) {
   if (ctxResult.findings.length > 0) {
     for (const f of ctxResult.findings.slice(0, 3)) lines.push(`    ${f.severity}: ${f.message}`);
   }
+  const ccLatest = loadLatestRuntimeSession(target);
+  if (ccLatest?.contextControl) {
+    const cc = ccLatest.contextControl;
+    lines.push("");
+    lines.push(`  Context Control: ${cc.status} (reduction=${cc.reductionPercent}%, evidence=${cc.evidenceRefCount}, blocked=${cc.blockedItemsCount})`);
+    if (cc.blockedItemsCount > 0) lines.push(`    WARNING: ${cc.blockedItemsCount} context item(s) blocked by policy`);
+    if (cc.proofImpact === "degraded") lines.push(`    WARNING: proof impact is degraded \u2014 evidence refs may be incomplete`);
+  }
   try {
     const { getModelRegistry: getModelRegistry2, getLocalModels: getLocalModels2, getAllProviders: getAllProviders2, isProviderAvailable: isProviderAvailable2 } = (init_model_routing2(), __toCommonJS(model_routing_exports));
     const models = getModelRegistry2();
@@ -19120,6 +20472,7 @@ function cmdStatus(args) {
       `  detected:     ${[contract.gitDetected ? "git" : "no-git", contract.packageDetected ? "package" : "no-package"].join(", ")}`,
       `  workspace:    local-only \xB7 cloud not claimed`,
       `  last run:     ${latest ? `${latest.status} (${latest.runtimeSessionId})` : "none yet"}`,
+      `  ctx control:  ${latest?.contextControl ? `${latest.contextControl.status} \xB7 reduction=${latest.contextControl.reductionPercent}%` : "not yet run"}`,
       `  routing:      seamless model routing active (local-first, no credentials required)`,
       `  control ctr:  available \u2014 avorelo control-center --target .`,
       `  next:         ${contract.firstRunRecommended.command} \u2014 ${contract.firstRunRecommended.reason}`,
@@ -19901,8 +21254,64 @@ function cmdContext(args) {
   const asJson = args.includes("--json");
   const task = args.slice(1).find((a) => !a.startsWith("--") && a !== target);
   if (sub === "check") return cmdContextCheck(args.slice(1));
+  if (sub === "stats") {
+    const latest = loadLatestRuntimeSession(target);
+    if (!latest?.contextControl) {
+      process.stderr.write("No context control data yet. Run a session first.\n");
+      return 1;
+    }
+    const cc = latest.contextControl;
+    process.stdout.write(renderContextStats({
+      contextControlStatus: cc.status === "optimized" ? "ACTIVE" : cc.status === "blocked" ? "BLOCKED" : "ACTIVE",
+      estimatedContextBefore: cc.estimatedContextBefore,
+      estimatedContextSent: cc.estimatedContextAfter,
+      reductionPercent: cc.reductionPercent,
+      evidenceRefCount: cc.evidenceRefCount,
+      blockedItemsCount: cc.blockedItemsCount,
+      retrievalAvailable: cc.retrievalAvailable,
+      proofImpact: cc.proofImpact,
+      topReasonCodes: cc.reasonCodes,
+      summary: `Context control ${cc.status}`
+    }) + "\n");
+    return 0;
+  }
+  if (sub === "explain") {
+    const latest = loadLatestRuntimeSession(target);
+    if (!latest?.contextControl) {
+      process.stderr.write("No context control data yet. Run a session first.\n");
+      return 1;
+    }
+    const cc = latest.contextControl;
+    process.stdout.write(renderContextExplain({
+      contextControlStatus: cc.status === "optimized" ? "ACTIVE" : cc.status === "blocked" ? "BLOCKED" : "ACTIVE",
+      estimatedContextBefore: cc.estimatedContextBefore,
+      estimatedContextSent: cc.estimatedContextAfter,
+      reductionPercent: cc.reductionPercent,
+      evidenceRefCount: cc.evidenceRefCount,
+      blockedItemsCount: cc.blockedItemsCount,
+      retrievalAvailable: cc.retrievalAvailable,
+      proofImpact: cc.proofImpact,
+      topReasonCodes: cc.reasonCodes,
+      summary: `Context control ${cc.status}`
+    }, []) + "\n");
+    return 0;
+  }
+  if (sub === "learn") {
+    if (!args.includes("--dry-run")) {
+      process.stderr.write("Usage: avorelo context learn --dry-run [--target <dir>]\nLearning candidates are dry-run only.\n");
+      return 2;
+    }
+    const result3 = generateLearningCandidates({ failurePatterns: [], receipts: [] });
+    process.stdout.write(`Learning candidates (dry-run): ${result3.candidates.length}
+`);
+    for (const c of result3.candidates) {
+      process.stdout.write(`  - [${c.priority}] ${c.label}: ${c.description}
+`);
+    }
+    return 0;
+  }
   if (sub !== "compile") {
-    process.stderr.write("Usage: avorelo context <compile|check> [args]\n");
+    process.stderr.write("Usage: avorelo context <compile|check|stats|explain|learn> [args]\n");
     return 2;
   }
   if (!task) {
@@ -19966,6 +21375,22 @@ function cmdReceipt(args) {
       target
     );
     process.stdout.write(output.stdout + "\n");
+    const latest = loadLatestRuntimeSession(target);
+    if (latest?.contextControl && !asJson) {
+      const cc = latest.contextControl;
+      process.stdout.write([
+        "",
+        "Context Control:",
+        `  Status:          ${cc.status}`,
+        `  Context before:  ${cc.estimatedContextBefore}`,
+        `  Context after:   ${cc.estimatedContextAfter}`,
+        `  Reduction:       ${cc.reductionPercent}%`,
+        `  Evidence refs:   ${cc.evidenceRefCount}`,
+        `  Blocked items:   ${cc.blockedItemsCount}`,
+        `  Proof impact:    ${cc.proofImpact}`,
+        ""
+      ].join("\n"));
+    }
     return output.exitCode;
   }
   process.stderr.write("Usage: avorelo receipt latest [--target <dir>] [--json]\n");
@@ -21469,6 +22894,7 @@ async function finalize(exitCode) {
   } catch {
   }
   if (_cmd !== "serve" && _cmd !== "webhook" && _cmd !== "sync") {
+    process.exitCode = exitCode;
     setTimeout(() => process.exit(exitCode), 50).unref();
   }
 }