@ngockhoale/ukit 1.1.6

package/templates/.claude/ukit/runtime/compact-threshold.mjs

@@ -0,0 +1,1013 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import {
+  buildCompactMachineKey,
+  buildRuntimePaths,
+  compactContextBlock,
+  compressLine,
+  estimateTokenCount,
+  readJson,
+} from './token-utils.mjs';
+
+const DEFAULT_MAX_PROMPT_ENTRIES = 12;
+const DEFAULT_MAX_OUTPUT_ENTRIES = 12;
+const DEFAULT_HISTORY_LAYER_COUNT = 2;
+const SOFT_RELEASE_RATIO = 0.9;
+const HARD_RELEASE_RATIO = 0.92;
+const PHASE_COOLDOWN_MS = {
+  soft: 5 * 60 * 1000,
+  hard: 10 * 60 * 1000,
+};
+const STOPWORDS = new Set([
+  'the', 'a', 'an', 'and', 'or', 'to', 'for', 'of', 'with', 'in', 'on', 'is', 'are',
+  'this', 'that', 'it', 'as', 'by', 'be', 'use', 'using', 'implement', 'fix', 'task',
+  'keep', 'please', 'remember', 'need', 'still',
+  'cần', 'và', 'là', 'cho', 'một', 'những', 'dùng',
+]);
+const EXPENDABLE_LINE_PATTERNS = [
+  /^-\s*debug\b/i,
+  /^-\s*progress\b/i,
+  /^-\s*download(?:ed|ing)?\b/i,
+  /^-\s*spinner\b/i,
+  /^-\s*duration\b/i,
+  /^-\s*start at\b/i,
+  /^-\s*trace\b/i,
+];
+
+function finiteNumber(value, fallback = 0) {
+  const number = Number(value);
+  return Number.isFinite(number) ? number : fallback;
+}
+
+function uniqueStrings(values) {
+  const seen = new Set();
+  const unique = [];
+  for (const value of values ?? []) {
+    const normalized = String(value ?? '').trim();
+    if (!normalized) continue;
+    const key = normalized.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    unique.push(normalized);
+  }
+  return unique;
+}
+
+function normalizeWhitespace(value) {
+  return String(value ?? '')
+    .replace(/[^\p{L}\p{N}\s./:_-]/gu, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+}
+
+function tokenizeFreeform(value) {
+  return normalizeWhitespace(value)
+    .split(/\s+/)
+    .filter((token) => token && token.length > 1);
+}
+
+function compressFreeformText(value, { maxWords = 18 } = {}) {
+  const words = tokenizeFreeform(value);
+  const selected = [];
+  const seen = new Set();
+
+  for (const word of words) {
+    const key = word.toLowerCase();
+    const keep = /[./:_-]/.test(word) || !STOPWORDS.has(key);
+    if (!keep || seen.has(key)) {
+      continue;
+    }
+    selected.push(word);
+    seen.add(key);
+    if (selected.length >= maxWords) {
+      break;
+    }
+  }
+
+  return selected.join(' ');
+}
+
+function normalizeTaskMode(taskMode) {
+  const normalized = String(taskMode ?? '').trim().toLowerCase();
+  return ['coding', 'chat', 'mixed'].includes(normalized) ? normalized : '';
+}
+
+function normalizePhase(phase) {
+  const normalized = String(phase ?? '').trim().toLowerCase();
+  return ['monitor', 'soft', 'hard'].includes(normalized) ? normalized : 'monitor';
+}
+
+function normalizeStats(rawStats = {}) {
+  return {
+    thresholdHits: finiteNumber(rawStats?.thresholdHits, 0),
+    softHits: finiteNumber(rawStats?.softHits, 0),
+    hardHits: finiteNumber(rawStats?.hardHits, 0),
+  };
+}
+
+function normalizeLatestPlan(latestPlan = null) {
+  if (!latestPlan || typeof latestPlan !== 'object') {
+    return null;
+  }
+
+  return {
+    ...latestPlan,
+    phase: normalizePhase(latestPlan.phase),
+    updatedAt: finiteNumber(latestPlan.updatedAt, Date.now()),
+    estimatedTotalTokens: finiteNumber(latestPlan.estimatedTotalTokens, 0),
+    tokensBefore: finiteNumber(latestPlan.tokensBefore, 0),
+    tokensAfter: finiteNumber(latestPlan.tokensAfter, 0),
+    savedTokens: finiteNumber(latestPlan.savedTokens, 0),
+    reusedCooldown: Boolean(latestPlan.reusedCooldown),
+  };
+}
+
+function summarizePromptText(promptText, routingContext = {}) {
+  const focus = compressFreeformText(promptText || routingContext?.lastExplicitUserPromptText || '', {
+    maxWords: 18,
+  });
+  const parts = [];
+  if (routingContext?.targetFile) {
+    parts.push(String(routingContext.targetFile).trim());
+  }
+  if (focus) {
+    parts.push(focus);
+  }
+  if (routingContext?.taskType) {
+    parts.unshift(`lane=${String(routingContext.taskType).trim()}`);
+  }
+  return parts.join(' | ');
+}
+
+function summarizeOutputText(summary, command) {
+  const summaryLines = String(summary ?? '')
+    .split(/\r?\n/)
+    .map((line) => compressLine(line))
+    .filter(Boolean)
+    .filter((line) => !EXPENDABLE_LINE_PATTERNS.some((pattern) => pattern.test(line)));
+  const lines = uniqueStrings([
+    command ? `command=${String(command).trim()}` : null,
+    ...summaryLines.slice(0, 3),
+  ]);
+  return lines.join(' | ');
+}
+
+function normalizePromptEntry(entry) {
+  if (!entry || typeof entry !== 'object') {
+    return null;
+  }
+
+  const summary = String(entry.summary ?? '').trim();
+  if (!summary) {
+    return null;
+  }
+
+  return {
+    kind: 'prompt',
+    timestamp: finiteNumber(entry.timestamp, Date.now()),
+    tokens: Math.max(1, finiteNumber(entry.tokens, estimateTokenCount(summary))),
+    summary,
+    targetFile: entry.targetFile ? String(entry.targetFile).trim() : null,
+    taskType: entry.taskType ? String(entry.taskType).trim() : null,
+  };
+}
+
+function normalizeOutputEntry(entry) {
+  if (!entry || typeof entry !== 'object') {
+    return null;
+  }
+
+  const summary = String(entry.summary ?? '').trim();
+  if (!summary) {
+    return null;
+  }
+
+  const tokensBefore = Math.max(1, finiteNumber(entry.tokensBefore, estimateTokenCount(summary)));
+  const tokensAfter = Math.max(1, finiteNumber(entry.tokensAfter, estimateTokenCount(summary)));
+
+  return {
+    kind: 'output',
+    timestamp: finiteNumber(entry.timestamp, Date.now()),
+    command: entry.command ? String(entry.command).trim() : '',
+    profile: entry.profile ? String(entry.profile).trim() : 'generic',
+    exitCode: Number.isFinite(Number(entry.exitCode)) ? Number(entry.exitCode) : null,
+    tokensBefore,
+    tokensAfter,
+    savedTokens: Math.max(0, finiteNumber(entry.savedTokens, tokensBefore - tokensAfter)),
+    summary,
+  };
+}
+
+function upsertEntry(entries, entry, { maxEntries = 10, keyBuilder } = {}) {
+  const key = typeof keyBuilder === 'function' ? keyBuilder(entry) : entry.summary;
+  const normalizedKey = String(key ?? '').trim().toLowerCase();
+  const remaining = (entries ?? []).filter((candidate) => {
+    const candidateKey = String(
+      typeof keyBuilder === 'function' ? keyBuilder(candidate) : candidate?.summary,
+    ).trim().toLowerCase();
+    return candidateKey !== normalizedKey;
+  });
+
+  return [entry, ...remaining].slice(0, maxEntries);
+}
+
+function deriveTaskMode({ routingContext = {}, recentOutputs = [], fallback = '' } = {}) {
+  const explicit = normalizeTaskMode(fallback);
+  const targetFile = String(routingContext?.targetFile ?? '').trim();
+  const promptText = String(routingContext?.lastExplicitUserPromptText ?? routingContext?.promptText ?? '').trim();
+  if (targetFile || /(src|tests?|docs|app|lib)\//i.test(promptText) || /\b(test|debug|fix|implement|refactor|build)\b/i.test(promptText)) {
+    return 'coding';
+  }
+
+  if ((recentOutputs ?? []).some((entry) => /(?:test-runner|search|paths|git|package-install|docker-logs)/.test(String(entry.profile ?? '')))) {
+    return 'coding';
+  }
+
+  if (promptText) {
+    return 'mixed';
+  }
+
+  if (explicit) {
+    return explicit;
+  }
+
+  return 'chat';
+}
+
+function summarizeHistoryLayer(items, { label, maxItems = 2 } = {}) {
+  const normalized = uniqueStrings((items ?? []).map((item) => String(item ?? '').trim()));
+  if (normalized.length === 0) {
+    return null;
+  }
+
+  const shown = normalized.slice(0, maxItems);
+  const remaining = normalized.length - shown.length;
+  return `- ${label}: ${shown.join(' | ')}${remaining > 0 ? ` | +${remaining} more` : ''}`;
+}
+
+function firstImportantOutputSignal(summary) {
+  const lines = String(summary ?? '')
+    .split(/\r?\n/)
+    .map((line) => compressLine(line))
+    .filter(Boolean)
+    .filter((line) => !/^-\s*recent command:/i.test(line));
+  return lines[0] ?? compressLine(summary);
+}
+
+function compactBridgeValue(value, { maxWords = 8 } = {}) {
+  const normalized = normalizeWhitespace(
+    String(value ?? '')
+      .replace(/\(\+\d+\s+more\)/gi, ' ')
+      .split(/\s*[;|]\s*/)[0] ?? '',
+  );
+  if (!normalized) {
+    return '';
+  }
+
+  const words = normalized.split(/\s+/).filter(Boolean);
+  return words.slice(0, Math.max(1, maxWords)).join(' ');
+}
+
+function parsePreviousContextBridge(previousLine) {
+  const summary = {};
+  const segments = String(previousLine ?? '')
+    .split(/\s+\|\s+(?=\[[^\]]+\])/)
+    .map((segment) => segment.trim())
+    .filter(Boolean);
+
+  for (const segment of segments) {
+    const clauses = segment
+      .split(/\s+—\s+/)
+      .map((clause) => clause.trim())
+      .filter(Boolean);
+    if (clauses.length === 0) {
+      continue;
+    }
+
+    const header = clauses.shift() ?? '';
+    const projectMatch = header.match(/^\[project\]\s*(.+)$/i);
+    const sessionMatch = header.match(/^\[session\]\s*(.+)$/i);
+    if (projectMatch && !summary.project) {
+      summary.project = compactBridgeValue(projectMatch[1], { maxWords: 6 });
+    }
+    if (sessionMatch && !summary.task) {
+      summary.task = compactBridgeValue(sessionMatch[1], { maxWords: 6 });
+    }
+
+    for (const clause of clauses) {
+      const separatorIndex = clause.indexOf(':');
+      if (separatorIndex <= 0) {
+        continue;
+      }
+
+      const rawKey = clause.slice(0, separatorIndex).trim().toLowerCase();
+      const value = compactBridgeValue(clause.slice(separatorIndex + 1), {
+        maxWords: rawKey === 'rules' ? 6 : 8,
+      });
+      if (!value) {
+        continue;
+      }
+
+      if (rawKey.startsWith('decision') && !summary.decision) {
+        summary.decision = value;
+      } else if ((rawKey === 'rule' || rawKey === 'rules') && !summary.rule) {
+        summary.rule = value;
+      } else if (rawKey === 'next' && !summary.next) {
+        summary.next = value;
+      } else if ((rawKey === 'action' || rawKey === 'actions') && !summary.action) {
+        summary.action = value;
+      } else if (rawKey === 'outcome' && !summary.outcome) {
+        summary.outcome = value;
+      }
+    }
+  }
+
+  return summary;
+}
+
+function parseRouteBridge(routeLine) {
+  const summary = {};
+  const segments = String(routeLine ?? '')
+    .split(/\s+\|\s+/)
+    .map((segment) => segment.trim())
+    .filter(Boolean);
+
+  for (const segment of segments) {
+    const separatorIndex = segment.indexOf('=');
+    if (separatorIndex <= 0) {
+      continue;
+    }
+
+    const rawKey = segment.slice(0, separatorIndex).trim().toLowerCase();
+    const value = compactBridgeValue(segment.slice(separatorIndex + 1), {
+      maxWords: rawKey === 'targets' ? 4 : 8,
+    });
+    if (!value) {
+      continue;
+    }
+
+    if (rawKey === 'task' && !summary.task) {
+      summary.task = value;
+    } else if ((rawKey === 'target' || rawKey === 'targets') && !summary.focus) {
+      summary.focus = value;
+    } else if (rawKey === 'next' && !summary.next) {
+      summary.next = value;
+    }
+  }
+
+  return summary;
+}
+
+function buildMemoryBridgeLine(routeState = {}, state = {}) {
+  const previousLine = String(routeState?.previousContext?.line ?? '').trim();
+  const routeLine = String(routeState?.routeSummary?.line ?? '').trim();
+  const promptSummary = String(state?.recentPrompts?.[0]?.summary ?? '').trim();
+  const previousBridge = parsePreviousContextBridge(previousLine);
+  const routeBridge = parseRouteBridge(routeLine);
+  const promptBridge = compactBridgeValue(promptSummary, { maxWords: 10 });
+  const parts = [];
+  const seenParts = new Set();
+  const trivialRouteTasks = new Set(['trivial', 'non-trivial', 'complex', 'mixed', 'chat', 'coding']);
+
+  function pushBridgePart(key, value) {
+    const normalizedValue = compactBridgeValue(value, {
+      maxWords: key === 'task' ? 6 : key === 'focus' ? 4 : 8,
+    });
+    if (!normalizedValue) {
+      return;
+    }
+
+    if (key === 'task' && trivialRouteTasks.has(normalizedValue.toLowerCase())) {
+      return;
+    }
+
+    const dedupeKey = `${key}:${normalizedValue}`.toLowerCase();
+    if (seenParts.has(dedupeKey)) {
+      return;
+    }
+    seenParts.add(dedupeKey);
+    parts.push(`${key}=${normalizedValue}`);
+  }
+
+  pushBridgePart('task', previousBridge.task || routeBridge.task || promptBridge);
+  pushBridgePart('decision', previousBridge.decision);
+  pushBridgePart('rule', previousBridge.rule);
+  pushBridgePart('next', previousBridge.next || routeBridge.next);
+  pushBridgePart('focus', routeBridge.focus);
+  if (parts.length === 0) {
+    pushBridgePart('project', previousBridge.project);
+    pushBridgePart('action', previousBridge.action);
+    pushBridgePart('outcome', previousBridge.outcome);
+  }
+
+  if (parts.length === 0 && !routeLine && !promptSummary) {
+    return null;
+  }
+
+  if (parts.length > 0) {
+    return `- Memory bridge: ${parts.join(' | ')}`;
+  }
+
+  return `- Memory bridge: ${uniqueStrings([routeLine, promptSummary]).join(' | ')}`;
+}
+
+function computeEstimatedContextTokens(state) {
+  return finiteNumber(state?.estimatedContextTokens, 0);
+}
+
+function computeEstimatedTotalTokens({
+  recentPrompts = [],
+  recentOutputs = [],
+  estimatedContextTokens = 0,
+  baselineTokens = 0,
+}) {
+  const promptTokens = recentPrompts.reduce((sum, entry) => sum + finiteNumber(entry.tokens, 0), 0);
+  const outputTokens = recentOutputs.reduce((sum, entry) => sum + finiteNumber(entry.tokensBefore ?? entry.tokens, 0), 0);
+  return baselineTokens + estimatedContextTokens + promptTokens + outputTokens;
+}
+
+export function buildCompactThresholds(config = {}) {
+  const softThreshold = Math.max(1, finiteNumber(config?.compact?.tokenThreshold, 100_000));
+  const hardThreshold = Math.max(softThreshold + 1, Math.round(softThreshold * 1.2));
+  const baselineTokens = Math.max(120, Math.min(18_000, Math.round(softThreshold * 0.18)));
+
+  return {
+    softThreshold,
+    hardThreshold,
+    baselineTokens,
+  };
+}
+
+function buildReleaseThresholds(thresholds = buildCompactThresholds()) {
+  const softReleaseThreshold = Math.max(
+    Math.min(thresholds.softThreshold, Math.round(thresholds.softThreshold * SOFT_RELEASE_RATIO)),
+    1,
+  );
+  const hardReleaseThreshold = Math.max(
+    thresholds.softThreshold,
+    Math.round(thresholds.hardThreshold * HARD_RELEASE_RATIO),
+  );
+
+  return {
+    softReleaseThreshold,
+    hardReleaseThreshold,
+  };
+}
+
+export function resolveCompactPhase(
+  estimatedTotalTokens,
+  thresholds = buildCompactThresholds(),
+  previousState = {},
+) {
+  const previousPhase = normalizePhase(previousState?.phase ?? previousState);
+  const releaseThresholds = buildReleaseThresholds(thresholds);
+  if (estimatedTotalTokens >= thresholds.hardThreshold) {
+    return 'hard';
+  }
+  if (previousPhase === 'hard' && estimatedTotalTokens >= releaseThresholds.hardReleaseThreshold) {
+    return 'hard';
+  }
+  if (estimatedTotalTokens >= thresholds.softThreshold) {
+    return 'soft';
+  }
+  if (previousPhase !== 'monitor' && estimatedTotalTokens >= releaseThresholds.softReleaseThreshold) {
+    return 'soft';
+  }
+  return 'monitor';
+}
+
+function resolvePhaseCooldownMs(phase) {
+  return PHASE_COOLDOWN_MS[normalizePhase(phase)] ?? 0;
+}
+
+function resolvePlanDeltaThreshold(phase, thresholds = buildCompactThresholds()) {
+  return normalizePhase(phase) === 'hard'
+    ? Math.max(60, Math.round(thresholds.hardThreshold * 0.14))
+    : Math.max(40, Math.round(thresholds.softThreshold * 0.12));
+}
+
+function isMaterialThresholdPlanChange(previousPlan, nextPlan, thresholds) {
+  if (!previousPlan || !nextPlan) {
+    return true;
+  }
+
+  if (normalizePhase(previousPlan.phase) !== normalizePhase(nextPlan.phase)) {
+    return true;
+  }
+
+  const estimatedDelta = Math.abs(
+    finiteNumber(nextPlan.estimatedTotalTokens, 0) - finiteNumber(previousPlan.estimatedTotalTokens, 0),
+  );
+  if (estimatedDelta >= resolvePlanDeltaThreshold(nextPlan.phase, thresholds)) {
+    return true;
+  }
+
+  const savedDelta = Math.abs(
+    finiteNumber(nextPlan.savedTokens, 0) - finiteNumber(previousPlan.savedTokens, 0),
+  );
+  if (savedDelta >= 40) {
+    return true;
+  }
+
+  const previousLines = Array.isArray(previousPlan.lines)
+    ? previousPlan.lines
+    : String(previousPlan.summary ?? '').split(/\r?\n/).filter(Boolean);
+  const nextLines = Array.isArray(nextPlan.lines)
+    ? nextPlan.lines
+    : String(nextPlan.summary ?? '').split(/\r?\n/).filter(Boolean);
+
+  if (previousLines.length === 0 || nextLines.length === 0) {
+    return false;
+  }
+
+  return Math.abs(nextLines.length - previousLines.length) >= 2;
+}
+
+export function resolveThresholdCompactBudget({
+  phase = 'monitor',
+  maxTokens = 280,
+  maxLines = 12,
+} = {}) {
+  const normalizedPhase = normalizePhase(phase);
+  if (normalizedPhase === 'hard') {
+    return {
+      maxTokens: Math.max(170, Math.round(maxTokens * 0.68)),
+      maxLines: Math.min(maxLines, 8),
+    };
+  }
+
+  if (normalizedPhase === 'soft') {
+    return {
+      maxTokens: Math.max(190, Math.round(maxTokens * 0.84)),
+      maxLines: Math.min(maxLines, 10),
+    };
+  }
+
+  return {
+    maxTokens,
+    maxLines,
+  };
+}
+
+export function buildCompactPressureState(rawState = null, config = {}) {
+  const thresholds = buildCompactThresholds(config);
+  const rawSoftThreshold = finiteNumber(rawState?.softThreshold, 0);
+  const rawHardThreshold = finiteNumber(rawState?.hardThreshold, 0);
+  if (!finiteNumber(config?.compact?.tokenThreshold, 0) && rawSoftThreshold > 0) {
+    thresholds.softThreshold = rawSoftThreshold;
+    thresholds.hardThreshold = rawHardThreshold > rawSoftThreshold
+      ? rawHardThreshold
+      : Math.max(rawSoftThreshold + 1, Math.round(rawSoftThreshold * 1.2));
+    thresholds.baselineTokens = Math.max(120, Math.min(18_000, Math.round(thresholds.softThreshold * 0.18)));
+  }
+  const recentPrompts = (Array.isArray(rawState?.recentPrompts) ? rawState.recentPrompts : [])
+    .map((entry) => normalizePromptEntry(entry))
+    .filter(Boolean)
+    .sort((left, right) => (right.timestamp ?? 0) - (left.timestamp ?? 0))
+    .slice(0, DEFAULT_MAX_PROMPT_ENTRIES);
+  const recentOutputs = (Array.isArray(rawState?.recentOutputs) ? rawState.recentOutputs : [])
+    .map((entry) => normalizeOutputEntry(entry))
+    .filter(Boolean)
+    .sort((left, right) => (right.timestamp ?? 0) - (left.timestamp ?? 0))
+    .slice(0, DEFAULT_MAX_OUTPUT_ENTRIES);
+  const estimatedContextTokens = computeEstimatedContextTokens(rawState);
+  const estimatedTotalTokens = finiteNumber(
+    rawState?.estimatedTotalTokens,
+    computeEstimatedTotalTokens({
+      recentPrompts,
+      recentOutputs,
+      estimatedContextTokens,
+      baselineTokens: thresholds.baselineTokens,
+    }),
+  );
+  const releaseThresholds = buildReleaseThresholds(thresholds);
+  const taskMode = deriveTaskMode({
+    routingContext: rawState?.routingContext ?? {},
+    recentOutputs,
+    fallback: rawState?.taskMode,
+  });
+
+  return {
+    updatedAt: finiteNumber(rawState?.updatedAt, Date.now()),
+    softThreshold: thresholds.softThreshold,
+    hardThreshold: thresholds.hardThreshold,
+    softReleaseThreshold: releaseThresholds.softReleaseThreshold,
+    hardReleaseThreshold: releaseThresholds.hardReleaseThreshold,
+    baselineTokens: thresholds.baselineTokens,
+    estimatedContextTokens,
+    estimatedTotalTokens,
+    phase: resolveCompactPhase(estimatedTotalTokens, thresholds, rawState),
+    taskMode,
+    cooldownUntil: finiteNumber(rawState?.cooldownUntil, 0),
+    routingContext: rawState?.routingContext && typeof rawState.routingContext === 'object'
+      ? rawState.routingContext
+      : {},
+    recentPrompts,
+    recentOutputs,
+    latestPlan: normalizeLatestPlan(rawState?.latestPlan),
+    historyLayers: uniqueStrings(rawState?.historyLayers ?? []).slice(0, DEFAULT_HISTORY_LAYER_COUNT),
+    stats: normalizeStats(rawState?.stats),
+  };
+}
+
+export function registerPromptPressure(state, {
+  promptText = '',
+  routingContext = {},
+  previousContext = null,
+  routeSummary = null,
+  timestamp = Date.now(),
+} = {}, config = {}) {
+  const current = buildCompactPressureState(state, config);
+  const normalizedPrompt = String(promptText || routingContext?.lastExplicitUserPromptText || '').trim();
+  if (!normalizedPrompt) {
+    return current;
+  }
+
+  const entry = normalizePromptEntry({
+    timestamp,
+    tokens: estimateTokenCount(normalizedPrompt),
+    summary: summarizePromptText(normalizedPrompt, routingContext),
+    targetFile: routingContext?.targetFile ?? null,
+    taskType: routingContext?.taskType ?? null,
+  });
+  const recentPrompts = entry
+    ? upsertEntry(current.recentPrompts, entry, {
+        maxEntries: DEFAULT_MAX_PROMPT_ENTRIES,
+        keyBuilder: (candidate) => `${candidate.targetFile ?? ''}|${candidate.summary ?? ''}`,
+      })
+    : current.recentPrompts;
+
+  return buildCompactPressureState({
+    ...current,
+    updatedAt: timestamp,
+    routingContext,
+    recentPrompts,
+    estimatedTotalTokens: undefined,
+    estimatedContextTokens: estimateTokenCount([
+      routeSummary?.line ?? '',
+      previousContext?.line ?? '',
+      summarizePromptText(normalizedPrompt, routingContext),
+    ].filter(Boolean).join('\n')),
+    taskMode: deriveTaskMode({
+      routingContext,
+      recentOutputs: current.recentOutputs,
+      fallback: current.taskMode,
+    }),
+  }, config);
+}
+
+export function registerOutputPressure(state, {
+  command = '',
+  profile = 'generic',
+  summary = '',
+  tokensBefore = 0,
+  tokensAfter = 0,
+  savedTokens = 0,
+  exitCode = null,
+  timestamp = Date.now(),
+} = {}, config = {}) {
+  const current = buildCompactPressureState(state, config);
+  const normalizedSummary = summarizeOutputText(summary, command);
+  if (!normalizedSummary) {
+    return current;
+  }
+
+  const entry = normalizeOutputEntry({
+    timestamp,
+    command,
+    profile,
+    exitCode,
+    tokensBefore: Math.max(1, finiteNumber(tokensBefore, estimateTokenCount(summary || normalizedSummary))),
+    tokensAfter: Math.max(1, finiteNumber(tokensAfter, estimateTokenCount(normalizedSummary))),
+    savedTokens: Math.max(0, finiteNumber(savedTokens, 0)),
+    summary: normalizedSummary,
+  });
+  const recentOutputs = upsertEntry(current.recentOutputs, entry, {
+    maxEntries: DEFAULT_MAX_OUTPUT_ENTRIES,
+    keyBuilder: (candidate) => `${candidate.command ?? ''}|${candidate.summary ?? ''}`,
+  });
+
+  return buildCompactPressureState({
+    ...current,
+    updatedAt: timestamp,
+    recentOutputs,
+    estimatedTotalTokens: undefined,
+    taskMode: deriveTaskMode({
+      routingContext: current.routingContext ?? {},
+      recentOutputs,
+      fallback: current.taskMode || (profile ? 'coding' : ''),
+    }),
+  }, config);
+}
+
+export function registerThresholdCompactPlan(state, plan, config = {}) {
+  const current = buildCompactPressureState(state, config);
+  if (!plan?.active) {
+    return current;
+  }
+
+  const thresholds = {
+    softThreshold: current.softThreshold,
+    hardThreshold: current.hardThreshold,
+  };
+  const now = Date.now();
+  const fingerprint = buildCompactMachineKey('threshold-plan-v1', {
+    phase: plan.phase,
+    estimatedTotalTokens: plan.estimatedTotalTokens,
+    lines: plan.lines,
+  });
+  if (current.latestPlan?.fingerprint === fingerprint) {
+    return buildCompactPressureState({
+      ...current,
+      updatedAt: now,
+      latestPlan: {
+        ...current.latestPlan,
+        updatedAt: now,
+      },
+    }, config);
+  }
+
+  const withinCooldown = (
+    current.latestPlan
+    && normalizePhase(current.latestPlan.phase) === normalizePhase(plan.phase)
+    && finiteNumber(current.cooldownUntil, 0) > now
+  );
+  const materialChange = isMaterialThresholdPlanChange(current.latestPlan, plan, thresholds);
+
+  if (withinCooldown && !materialChange) {
+    return buildCompactPressureState({
+      ...current,
+      updatedAt: now,
+      latestPlan: {
+        ...current.latestPlan,
+        fingerprint,
+        phase: normalizePhase(plan.phase),
+        estimatedTotalTokens: finiteNumber(plan.estimatedTotalTokens, 0),
+        tokensBefore: finiteNumber(plan.tokensBefore, 0),
+        tokensAfter: finiteNumber(plan.tokensAfter, 0),
+        savedTokens: finiteNumber(plan.savedTokens, 0),
+        summary: Array.isArray(plan.lines) ? plan.lines.join('\n') : current.latestPlan?.summary ?? '',
+        updatedAt: now,
+        reusedCooldown: true,
+      },
+    }, config);
+  }
+
+  const stats = normalizeStats(current.stats);
+  stats.thresholdHits += 1;
+  if (plan.phase === 'hard') {
+    stats.hardHits += 1;
+  } else if (plan.phase === 'soft') {
+    stats.softHits += 1;
+  }
+
+  return buildCompactPressureState({
+    ...current,
+    updatedAt: now,
+    cooldownUntil: now + resolvePhaseCooldownMs(plan.phase),
+    historyLayers: uniqueStrings(plan.layers ?? []).slice(0, DEFAULT_HISTORY_LAYER_COUNT),
+    latestPlan: {
+      fingerprint,
+      updatedAt: now,
+      phase: plan.phase,
+      estimatedTotalTokens: plan.estimatedTotalTokens,
+      tokensBefore: plan.tokensBefore,
+      tokensAfter: plan.tokensAfter,
+      savedTokens: plan.savedTokens,
+      summary: Array.isArray(plan.lines) ? plan.lines.join('\n') : '',
+      reusedCooldown: false,
+    },
+    stats,
+  }, config);
+}
+
+export function buildThresholdCompactPlan({
+  state,
+  config = {},
+  routeState = {},
+  staticLines = [],
+  dynamicLines = [],
+  maxTokens = 280,
+} = {}) {
+  const normalizedState = buildCompactPressureState(state, config);
+  const thresholds = buildCompactThresholds(config);
+  const phase = normalizedState.phase;
+  if (phase === 'monitor') {
+    return {
+      active: false,
+      phase,
+      estimatedTotalTokens: normalizedState.estimatedTotalTokens,
+      lines: [],
+      layers: normalizedState.historyLayers,
+      tokensBefore: 0,
+      tokensAfter: 0,
+      savedTokens: 0,
+    };
+  }
+
+  const budget = resolveThresholdCompactBudget({
+    phase,
+    maxTokens,
+    maxLines: 12,
+  });
+  const laneLine = (staticLines ?? []).find((line) => String(line ?? '').startsWith('- Current lane:'))
+    ?? (routeState?.routingContext?.taskType
+      ? `- Current lane: ${routeState.routingContext.taskType}`
+      : null);
+  const worklogLine = phase === 'hard'
+    ? null
+    : ((staticLines ?? []).find((line) => String(line ?? '').startsWith('- WORKLOG:')) ?? null);
+  const routeLine = (dynamicLines ?? []).find((line) => String(line ?? '').startsWith('- Recent routed lane:'))
+    ?? (routeState?.routeSummary?.line ? `- Recent routed lane: ${routeState.routeSummary.line}` : null);
+  const previousLine = (dynamicLines ?? []).find((line) => String(line ?? '').startsWith('- Previous context:'))
+    ?? (routeState?.previousContext?.line ? `- Previous context: ${routeState.previousContext.line}` : null);
+  const outputLine = (dynamicLines ?? []).find((line) => String(line ?? '').startsWith('- Recent command output:'))
+    ?? (
+      normalizedState.recentOutputs[0]?.summary
+        ? `- Recent command output: ${firstImportantOutputSignal(normalizedState.recentOutputs[0]?.summary)}`
+        : null
+    );
+  const verificationLine = (dynamicLines ?? []).find((line) => /broad verification/i.test(String(line ?? ''))) ?? null;
+  const thresholdLine = `- Threshold compact: ${phase} (est ${normalizedState.estimatedTotalTokens} / soft ${thresholds.softThreshold} / hard ${thresholds.hardThreshold}). Compact duplicates/logs only; preserve critical context.`;
+  const taskModeLine = `- Task-aware mode: ${normalizedState.taskMode || 'mixed'} => preserve active task, rules, decisions, and current code focus.`;
+  const memoryBridgeLine = buildMemoryBridgeLine(routeState, normalizedState);
+  const recentFocusLine = summarizeHistoryLayer([
+    normalizedState.recentPrompts[0]?.summary,
+    firstImportantOutputSignal(normalizedState.recentOutputs[0]?.summary),
+  ], {
+    label: 'Recent focus',
+    maxItems: 2,
+  });
+  const layerOne = summarizeHistoryLayer([
+    ...normalizedState.recentPrompts.slice(1, 3).map((entry) => entry.summary),
+    ...normalizedState.recentOutputs.slice(1, 3).map((entry) => firstImportantOutputSignal(entry.summary)),
+  ], {
+    label: 'Layer 1 summary',
+    maxItems: 2,
+  });
+  const layerTwo = phase === 'hard'
+    ? summarizeHistoryLayer([
+        ...normalizedState.recentPrompts.slice(3).map((entry) => entry.summary),
+        ...normalizedState.recentOutputs.slice(3).map((entry) => firstImportantOutputSignal(entry.summary)),
+      ], {
+        label: 'Layer 2 summary',
+        maxItems: 2,
+      })
+    : null;
+  const askBeforeDropLine = Boolean(config?.compact?.askBeforeDrop)
+    ? '- Ask-before-drop: if older decisions, rules, or unresolved failures still matter, confirm with the user before removing them.'
+    : null;
+
+  const rawLines = uniqueStrings([
+    thresholdLine,
+    taskModeLine,
+    laneLine,
+    worklogLine,
+    routeLine,
+    previousLine,
+    outputLine,
+    memoryBridgeLine,
+    recentFocusLine,
+    layerOne,
+    layerTwo,
+    askBeforeDropLine,
+    verificationLine,
+    ...(dynamicLines ?? []).filter((line) => {
+      const normalized = compressLine(line);
+      if (!normalized) return false;
+      if (normalized === routeLine || normalized === previousLine || normalized === outputLine || normalized === verificationLine) {
+        return false;
+      }
+      return !EXPENDABLE_LINE_PATTERNS.some((pattern) => pattern.test(normalized));
+    }),
+  ]);
+
+  const compacted = compactContextBlock(rawLines, {
+    maxTokens: budget.maxTokens,
+    maxLines: budget.maxLines,
+    anchorLines: [
+      thresholdLine,
+      routeLine,
+      previousLine,
+      outputLine,
+      memoryBridgeLine,
+      askBeforeDropLine,
+    ].filter(Boolean),
+    maxAnchors: 6,
+  });
+
+  return {
+    active: true,
+    phase,
+    estimatedTotalTokens: normalizedState.estimatedTotalTokens,
+    taskMode: normalizedState.taskMode,
+    budgetTokens: budget.maxTokens,
+    budgetLines: budget.maxLines,
+    lines: compacted.text ? compacted.text.split(/\r?\n/) : [],
+    layers: [layerOne, layerTwo].filter(Boolean),
+    tokensBefore: compacted.tokensBefore,
+    tokensAfter: compacted.tokensAfter,
+    savedTokens: compacted.savedTokens,
+  };
+}
+
+export async function readCompactPressureState(projectRoot, config = {}) {
+  const runtimePaths = buildRuntimePaths(projectRoot);
+  return buildCompactPressureState(await readJson(runtimePaths.compactPressurePath, null), config);
+}
+
+export async function writeCompactPressureState(projectRoot, state, config = {}) {
+  const runtimePaths = buildRuntimePaths(projectRoot);
+  const normalized = buildCompactPressureState(state, config);
+  await fs.mkdir(path.dirname(runtimePaths.compactPressurePath), { recursive: true });
+  await fs.writeFile(runtimePaths.compactPressurePath, `${JSON.stringify(normalized, null, 2)}\n`, 'utf8');
+  return normalized;
+}
+
+export async function updateCompactPressureFromPrompt(projectRoot, payload, config = {}) {
+  const current = await readCompactPressureState(projectRoot, config);
+  const next = registerPromptPressure(current, payload, config);
+  return writeCompactPressureState(projectRoot, next, config);
+}
+
+export async function updateCompactPressureFromOutput(projectRoot, payload, config = {}) {
+  const current = await readCompactPressureState(projectRoot, config);
+  const next = registerOutputPressure(current, payload, config);
+  return writeCompactPressureState(projectRoot, next, config);
+}
+
+export async function writeThresholdCompactPlan(projectRoot, plan, config = {}) {
+  const current = await readCompactPressureState(projectRoot, config);
+  const next = registerThresholdCompactPlan(current, plan, config);
+  return writeCompactPressureState(projectRoot, next, config);
+}
+
+async function loadRuntimeConfig(projectRoot) {
+  const runtimePaths = buildRuntimePaths(projectRoot);
+  const raw = await readJson(runtimePaths.configPath, {});
+  return raw && typeof raw === 'object' ? raw : {};
+}
+
+async function readStdin() {
+  if (process.stdin.isTTY) {
+    return '';
+  }
+
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(typeof chunk === 'string' ? chunk : chunk.toString('utf8'));
+  }
+  return chunks.join('');
+}
+
+function extractPrompt(payload = {}) {
+  const candidates = [
+    payload.prompt,
+    payload.user_prompt,
+    payload.text,
+    payload.message,
+    payload.input,
+  ];
+  return candidates.find((value) => typeof value === 'string' && value.trim()) || '';
+}
+
+async function runCli() {
+  const mode = String(process.argv[2] ?? '').trim();
+  if (!mode) {
+    return;
+  }
+
+  const projectRoot = process.env.CLAUDE_PROJECT_DIR || process.env.PROJECT_ROOT || process.cwd();
+  const config = await loadRuntimeConfig(projectRoot);
+  const rawInput = await readStdin();
+  const payload = (() => {
+    try {
+      return JSON.parse(rawInput || '{}');
+    } catch {
+      return {};
+    }
+  })();
+
+  if (mode === 'prompt') {
+    const routeState = await readJson(path.join(projectRoot, '.claude', 'ukit', 'skill-router-state.json'), {});
+    const promptText = extractPrompt(payload);
+    if (!promptText.trim()) {
+      return;
+    }
+
+    await updateCompactPressureFromPrompt(projectRoot, {
+      promptText,
+      routingContext: routeState?.routingContext ?? {},
+      previousContext: routeState?.previousContext ?? null,
+      routeSummary: routeState?.routeSummary ?? null,
+    }, config);
+  }
+}
+
+const invokedPath = process.argv[1] ? path.resolve(process.argv[1]) : null;
+if (invokedPath && pathToFileURL(invokedPath).href === import.meta.url) {
+  runCli().catch(() => {
+    process.exit(0);
+  });
+}