dsh-context-compression-improved 0.4.0-beta.1 → 0.5.0

package/packages/selector/lib/{config.js → advisor-state.js}

@@ -394,7 +394,13 @@ function parsePresetOptionsSettings(value) {
 		"reviewMode",
 		"reviewTimeoutTurns",
 		"cacheHitDiscountAlpha",
-		"reviewHighImpactTokens"
+		"reviewHighImpactTokens",
+		"advisorMode",
+		"advisorTimeoutMs",
+		"advisorRefreshTurns",
+		"advisorScoreThreshold",
+		"advisorSampleLimit",
+		"advisorMinTokens"
 	]);
 	const unknown = Object.keys(value).find((key) => !allowed.has(key));
 	if (unknown !== void 0) throw new TypeError(`Context-compression presetOptions: unknown key "${unknown}"`);
@@ -410,6 +416,18 @@ function parsePresetOptionsSettings(value) {
 	}
 	const estimatorMode = value.estimatorMode;
 	if (estimatorMode !== void 0 && estimatorMode !== "" && estimatorMode !== "host" && estimatorMode !== "direct") throw new TypeError("Context-compression presetOptions.estimatorMode must be \"\", \"host\", or \"direct\"");
+	const advisorMode = value.advisorMode;
+	if (advisorMode !== void 0 && advisorMode !== "" && advisorMode !== "host" && advisorMode !== "direct") throw new TypeError("Context-compression presetOptions.advisorMode must be \"\", \"host\", or \"direct\"");
+	const advisorTimeoutMs = value.advisorTimeoutMs;
+	if (advisorTimeoutMs !== void 0 && (typeof advisorTimeoutMs !== "number" || !Number.isSafeInteger(advisorTimeoutMs) || advisorTimeoutMs < 100 || advisorTimeoutMs > 6e4)) throw new TypeError("Context-compression presetOptions.advisorTimeoutMs must be an integer between 100 and 60000");
+	const advisorRefreshTurns = value.advisorRefreshTurns;
+	if (advisorRefreshTurns !== void 0 && (typeof advisorRefreshTurns !== "number" || !Number.isSafeInteger(advisorRefreshTurns) || advisorRefreshTurns < 1)) throw new TypeError("Context-compression presetOptions.advisorRefreshTurns must be an integer of at least 1");
+	const advisorScoreThreshold = value.advisorScoreThreshold;
+	if (advisorScoreThreshold !== void 0 && (typeof advisorScoreThreshold !== "number" || !Number.isFinite(advisorScoreThreshold) || advisorScoreThreshold <= 0 || advisorScoreThreshold >= 1)) throw new TypeError("Context-compression presetOptions.advisorScoreThreshold must be a number strictly between 0 and 1");
+	const advisorSampleLimit = value.advisorSampleLimit;
+	if (advisorSampleLimit !== void 0 && (typeof advisorSampleLimit !== "number" || !Number.isSafeInteger(advisorSampleLimit) || advisorSampleLimit < 1 || advisorSampleLimit > 64)) throw new TypeError("Context-compression presetOptions.advisorSampleLimit must be an integer between 1 and 64");
+	const advisorMinTokens = value.advisorMinTokens;
+	if (advisorMinTokens !== void 0 && (typeof advisorMinTokens !== "number" || !Number.isSafeInteger(advisorMinTokens) || advisorMinTokens < 1)) throw new TypeError("Context-compression presetOptions.advisorMinTokens must be a positive integer");
 	const estimatorTimeoutMs = value.estimatorTimeoutMs;
 	if (estimatorTimeoutMs !== void 0 && (typeof estimatorTimeoutMs !== "number" || !Number.isSafeInteger(estimatorTimeoutMs) || estimatorTimeoutMs < 100 || estimatorTimeoutMs > 6e4)) throw new TypeError("Context-compression presetOptions.estimatorTimeoutMs must be an integer between 100 and 60000");
 	const reviewTimeoutTurns = value.reviewTimeoutTurns;
@@ -442,6 +460,12 @@ function parsePresetOptionsSettings(value) {
 	if (reviewTimeoutTurns !== void 0) result.reviewTimeoutTurns = reviewTimeoutTurns;
 	if (cacheHitDiscountAlpha !== void 0) result.cacheHitDiscountAlpha = cacheHitDiscountAlpha;
 	if (reviewHighImpactTokens !== void 0) result.reviewHighImpactTokens = reviewHighImpactTokens;
+	if (advisorMode !== void 0) result.advisorMode = advisorMode;
+	if (advisorTimeoutMs !== void 0) result.advisorTimeoutMs = advisorTimeoutMs;
+	if (advisorRefreshTurns !== void 0) result.advisorRefreshTurns = advisorRefreshTurns;
+	if (advisorScoreThreshold !== void 0) result.advisorScoreThreshold = advisorScoreThreshold;
+	if (advisorSampleLimit !== void 0) result.advisorSampleLimit = advisorSampleLimit;
+	if (advisorMinTokens !== void 0) result.advisorMinTokens = advisorMinTokens;
 	return result;
 }
 /** Settings schema used by the user-facing profile selector. */
@@ -518,6 +542,7 @@ const CONFIG_KEYS = /* @__PURE__ */ new Set([
 	"historyKeepRecentToolCalls",
 	"historyKeepRecentTokens",
 	"historyMinReclaimTokens",
+	"readInputCapChars",
 	"autoCompactThresholdPercent",
 	"presetOptions"
 ]);
@@ -542,6 +567,15 @@ function codePointLength(text) {
 	for (const _point of text) length++;
 	return length;
 }
+/** Express one token-named policy gate on the character basis. */
+function charsForTokens(tokens) {
+	return tokens * 4;
+}
+/** Derive the telemetry-only token figure from a character measurement. */
+function charsToTokens(chars) {
+	if (!Number.isFinite(chars) || chars <= 0) return 0;
+	return Math.max(1, Math.round(chars / 4));
+}
 /**
 * Test whether a settings value names a supported compression profile.
 * @param value - untrusted settings value.
@@ -575,6 +609,7 @@ function resolveConfig(config = {}) {
 		...config.historyKeepRecentToolCalls === void 0 ? {} : { historyKeepRecentToolCalls: config.historyKeepRecentToolCalls },
 		...config.historyKeepRecentTokens === void 0 ? {} : { historyKeepRecentTokens: config.historyKeepRecentTokens },
 		...config.historyMinReclaimTokens === void 0 ? {} : { historyMinReclaimTokens: config.historyMinReclaimTokens },
+		...config.readInputCapChars === void 0 ? {} : { readInputCapChars: config.readInputCapChars },
 		...config.autoCompactThresholdPercent === void 0 ? {} : { autoCompactThresholdPercent: config.autoCompactThresholdPercent },
 		...config.presetOptions === void 0 ? {} : { presetOptions: config.presetOptions }
 	};
@@ -589,7 +624,8 @@ function resolveConfig(config = {}) {
 		"aggregateTriggerTokens",
 		"aggregateTargetTokens",
 		"historyTriggerTokens",
-		"historyMinReclaimTokens"
+		"historyMinReclaimTokens",
+		"readInputCapChars"
 	]) {
 		const value = resolved[key];
 		if (value !== void 0) assertPositiveInteger(key, value);
@@ -648,7 +684,15 @@ const PRESET_OPTION_DEFAULTS = deepFreeze({
 	reviewMode: false,
 	reviewTimeoutTurns: 6,
 	cacheHitDiscountAlpha: .1,
-	reviewHighImpactTokens: 4e3
+	reviewHighImpactTokens: 4e3,
+	advisor: {
+		mode: "",
+		timeoutMs: 8e3,
+		refreshTurns: 8,
+		scoreThreshold: .35,
+		sampleLimit: 16,
+		minTokens: 250
+	}
 });
 /**
 * Merge persisted presetOptions overrides over the tokenpilot-inspired
@@ -668,7 +712,15 @@ function mergePresetOptions(overrides) {
 		reviewMode: overrides.reviewMode ?? PRESET_OPTION_DEFAULTS.reviewMode,
 		reviewTimeoutTurns: overrides.reviewTimeoutTurns ?? PRESET_OPTION_DEFAULTS.reviewTimeoutTurns,
 		cacheHitDiscountAlpha: overrides.cacheHitDiscountAlpha ?? PRESET_OPTION_DEFAULTS.cacheHitDiscountAlpha,
-		reviewHighImpactTokens: overrides.reviewHighImpactTokens ?? PRESET_OPTION_DEFAULTS.reviewHighImpactTokens
+		reviewHighImpactTokens: overrides.reviewHighImpactTokens ?? PRESET_OPTION_DEFAULTS.reviewHighImpactTokens,
+		advisor: {
+			mode: overrides.advisorMode ?? PRESET_OPTION_DEFAULTS.advisor.mode,
+			timeoutMs: overrides.advisorTimeoutMs ?? PRESET_OPTION_DEFAULTS.advisor.timeoutMs,
+			refreshTurns: overrides.advisorRefreshTurns ?? PRESET_OPTION_DEFAULTS.advisor.refreshTurns,
+			scoreThreshold: overrides.advisorScoreThreshold ?? PRESET_OPTION_DEFAULTS.advisor.scoreThreshold,
+			sampleLimit: overrides.advisorSampleLimit ?? PRESET_OPTION_DEFAULTS.advisor.sampleLimit,
+			minTokens: overrides.advisorMinTokens ?? PRESET_OPTION_DEFAULTS.advisor.minTokens
+		}
 	});
 }
 /**
@@ -840,6 +892,7 @@ function resolvePolicy(config, profile, custom = DEFAULT_CUSTOM_COMPRESSION_POLI
 		historyKeepRecentToolCalls: config.historyKeepRecentToolCalls ?? preset.historyKeepRecentToolCalls,
 		historyKeepRecentTokens: config.historyKeepRecentTokens ?? linkage?.historyKeepRecentTokens ?? preset.historyKeepRecentTokens,
 		historyMinReclaimTokens: config.historyMinReclaimTokens ?? linkage?.historyMinReclaimTokens ?? preset.historyMinReclaimTokens,
+		...config.readInputCapChars === void 0 ? {} : { readInputCapChars: config.readInputCapChars },
 		...linkage === void 0 ? {} : {
 			autoCompactTokens: linkage.autoCompactTokens,
 			microDeadlineTokens: linkage.microDeadlineTokens
@@ -849,6 +902,7 @@ function resolvePolicy(config, profile, custom = DEFAULT_CUSTOM_COMPRESSION_POLI
 	if (policy.nativeTargetTokens >= policy.nativeTriggerTokens && profile === "native") throw new Error("context compression policy: native target must be below trigger");
 	if (policy.freshTargetTokens >= policy.freshTriggerTokens && policy.freshEnabled) throw new Error("context compression policy: fresh target must be below trigger");
 	if (policy.aggregateTargetTokens >= policy.aggregateTriggerTokens && policy.freshEnabled) throw new Error("context compression policy: aggregate target must be below trigger");
+	if (policy.readInputCapChars !== void 0 && policy.readInputCapChars <= policy.freshTriggerTokens * 4) throw new Error("context compression policy: read input cap would silence the fresh path");
 	return deepFreeze(policy);
 }
 function assertTargetBelowTrigger(label, target, trigger) {
@@ -862,4 +916,274 @@ function assertNonNegativeInteger(name, value) {
 	if (!Number.isSafeInteger(value) || value < 0) throw new Error(`ToolResultPruneConfig: ${name} (${String(value)}) must be a non-negative safe integer`);
 }
 //#endregion
-export { COMPRESSION_PROFILES as _, PRUNE_MARKER as a, isValidAutoCompactThresholdPercent as c, resolvePolicy as d, CustomCompressionPolicySchema as f, deepFreeze as g, assertNever as h, DEFAULTS as i, parseContextCompressionSettings as l, resolveCustomPolicy as m, CONTEXT_COMPRESSION_SETTINGS_NAMESPACE as n, codePointLength as o, DEFAULT_CUSTOM_COMPRESSION_POLICY as p, ContextCompressionSettingsSchema as r, isCompressionProfile as s, AUTO_COMPACT_THRESHOLD_LIMITS as t, resolveConfig as u };
+//#region src/runtime/tokenpilot/review-queue.ts
+/** In-memory store: the fail-open fallback when no durable seam is available. */
+var MemoryReviewStore = class {
+	sessions = /* @__PURE__ */ new Map();
+	load(sessionId) {
+		return this.sessions.get(sessionId);
+	}
+	save(sessionId, record) {
+		this.sessions.set(sessionId, record);
+	}
+	ids() {
+		return [...this.sessions.keys()];
+	}
+};
+var ReviewQueue = class {
+	store;
+	options;
+	constructor(store, options) {
+		this.store = store;
+		this.options = options;
+	}
+	/**
+	* Fail-open store access: a throwing seam must never break the compression
+	* pipeline. Reads degrade to "no stored record"; writes degrade to losing
+	* durability for that call (the store itself is expected to warn).
+	*/
+	safeLoad(sessionId) {
+		try {
+			return this.store.load(sessionId);
+		} catch {
+			return;
+		}
+	}
+	safeSave(sessionId, record) {
+		try {
+			this.store.save(sessionId, record);
+		} catch {}
+	}
+	sessionRecord(sessionId) {
+		return this.safeLoad(sessionId) ?? {
+			version: 1,
+			proposals: []
+		};
+	}
+	/**
+	* Queue one classified proposal. A repeated classification of the same
+	* content re-does nothing but refresh the patience clock, so re-enqueue
+	* cannot duplicate a live proposal.
+	* @returns `false` when an identical live proposal already exists.
+	*/
+	enqueue(sessionId, skeleton, turnIndex) {
+		const record = this.sessionRecord(sessionId);
+		const existing = record.proposals.find((entry) => entry.id === skeleton.id);
+		if (existing !== void 0 && existing.status !== "expired") {
+			existing.lastTurnIndex = turnIndex;
+			this.safeSave(sessionId, record);
+			return false;
+		}
+		const proposal = {
+			id: skeleton.id,
+			sessionId,
+			kind: skeleton.kind,
+			items: skeleton.items.map((item) => ({ ...item })),
+			benefit: { ...skeleton.benefit },
+			status: "pending",
+			enqueuedTurn: turnIndex,
+			lastTurnIndex: turnIndex
+		};
+		this.safeSave(sessionId, {
+			version: 1,
+			proposals: [...record.proposals.filter((entry) => entry.id !== skeleton.id), proposal]
+		});
+		return true;
+	}
+	/** Live pending proposals of one session, oldest enqueue first. */
+	listPending(sessionId) {
+		return this.sessionRecord(sessionId).proposals.filter((entry) => entry.status === "pending").sort((left, right) => left.enqueuedTurn - right.enqueuedTurn);
+	}
+	/** Approved proposals waiting for the next turn-boundary batch. */
+	listApproved(sessionId) {
+		return this.sessionRecord(sessionId).proposals.filter((entry) => entry.status === "approved").sort((left, right) => left.enqueuedTurn - right.enqueuedTurn);
+	}
+	/**
+	* Transition one pending proposal. Idempotent: deciding an unknown id or a
+	* non-pending proposal changes nothing and reports the miss.
+	*/
+	decide(sessionId, id, decision) {
+		const record = this.sessionRecord(sessionId);
+		const proposal = record.proposals.find((entry) => entry.id === id);
+		if (proposal === void 0) return {
+			ok: false,
+			reason: "unknown-proposal"
+		};
+		if (proposal.status !== "pending") return {
+			ok: false,
+			reason: "not-pending"
+		};
+		proposal.status = decision;
+		this.safeSave(sessionId, record);
+		return { ok: true };
+	}
+	/**
+	* Expire every pending proposal whose patience has run out at this turn
+	* boundary. Expired proposals are removed from the store (the summary view
+	* aggregates them from the audit log instead).
+	* @returns the expired proposals, for the caller's audit emission.
+	*/
+	expireTurn(sessionId, turnIndex) {
+		const record = this.sessionRecord(sessionId);
+		const keep = [];
+		const expired = [];
+		for (const proposal of record.proposals) {
+			if (proposal.status === "pending" && turnIndex - proposal.lastTurnIndex > this.options.timeoutTurns) {
+				expired.push({
+					...proposal,
+					status: "expired"
+				});
+				continue;
+			}
+			keep.push(proposal);
+		}
+		if (expired.length > 0) this.safeSave(sessionId, {
+			version: 1,
+			proposals: keep
+		});
+		return expired;
+	}
+	/**
+	* Settle an approved proposal with its execution receipt and retire it from
+	* the live store. The caller is responsible for auditing the receipt; the
+	* queue only records which proposal left and why.
+	*/
+	recordReceipt(sessionId, id, receipt) {
+		const record = this.sessionRecord(sessionId);
+		const proposal = record.proposals.find((entry) => entry.id === id);
+		if (proposal === void 0 || proposal.status !== "approved") return void 0;
+		this.safeSave(sessionId, {
+			version: 1,
+			proposals: record.proposals.filter((entry) => entry.id !== id)
+		});
+		return {
+			...proposal,
+			receipt
+		};
+	}
+};
+//#endregion
+//#region src/runtime/tokenpilot/review-registry.ts
+/**
+* Scope-independent handle on the live review pipeline.
+*
+* The R4 HTTP routes are registered on the plugin's TOP-LEVEL fiber
+* (`cordis.patch.yml` → `context-compression-improved-estimator-catalog`),
+* but every `ToolResultPruner` is mounted inside an agent preset's isolated
+* group — `canonicalCompressionRows()` declares
+* `isolate: { compaction: true, toolResultPruner: true }` — so
+* `ctx.get('toolResultPruner')` at the top level is always `undefined` and the
+* queue route could only ever answer 503 "review pipeline unavailable".
+*
+* Ownership, not transport, was in the wrong place: the queue records are
+* already keyed by session id, so the store belongs to the plugin rather than
+* to one pruner instance. Every instance shares one store and publishes itself
+* here, which lets a top-level reader reach whichever instance currently holds
+* a session's proposals.
+*
+* The durable seam already behaves this way — `REVIEW_STORAGE_DOMAIN` /
+* `REVIEW_STORAGE_TABLE` are constants, so every instance opens the same table.
+* Only the in-memory fallback was per-instance, and that is what this module
+* makes shared.
+*
+* @module dsh-context-compression-improved/review-registry
+*/
+/**
+* The one in-memory fallback every pruner instance starts from. Session ids are
+* globally unique and `ReviewSessionRecord` is keyed by them, so a single store
+* is semantically identical to one store per instance — except that a reader
+* reaching any instance now observes every session.
+*/
+const sharedStore = new MemoryReviewStore();
+const live = /* @__PURE__ */ new Set();
+/** The process-wide review queue store shared by every pruner instance. */
+function sharedReviewStore() {
+	return sharedStore;
+}
+/**
+* Publish one pruner instance for scope-independent readers.
+* @param pruner - the instance to publish.
+* @returns the disposer removing it, for `ctx.effect`.
+*/
+function registerReviewPruner(pruner) {
+	live.add(pruner);
+	return () => {
+		live.delete(pruner);
+	};
+}
+/**
+* Resolve a live pruner instance for the top-level routes.
+*
+* Any instance can serve an aggregate read because the store is shared, and a
+* session-scoped read is answered from that same store. Instances that have
+* upgraded to the durable seam read the same table, so the answer does not
+* depend on which instance this happens to return.
+*
+* @returns a live instance, or `undefined` when no preset has been composed yet.
+*/
+function resolveReviewPruner() {
+	return live.values().next().value;
+}
+const advisorStates = /* @__PURE__ */ new WeakMap();
+/**
+* The per-session advisor state, created on first touch.
+* @param session - the session to key the state on (by object identity).
+*/
+function getAdvisorState(session) {
+	let state = advisorStates.get(session);
+	if (state === void 0) {
+		state = {
+			todoVersion: void 0,
+			summary: void 0,
+			lastSummaryTurn: -1,
+			watermarkSeq: 0,
+			scores: /* @__PURE__ */ new Map(),
+			recertified: /* @__PURE__ */ new Map(),
+			failures: void 0,
+			inFlight: false,
+			lastDecay: void 0
+		};
+		advisorStates.set(session, state);
+	}
+	return state;
+}
+/**
+* Insert or refresh one score with LRU semantics: a re-touched seq moves to
+* the newest position, and the oldest entry is evicted once the map exceeds
+* {@link ADVISOR_SCORES_LIMIT}.
+*/
+function recordScore(state, seq, entry) {
+	state.scores.delete(seq);
+	state.scores.set(seq, entry);
+	if (state.scores.size > 64) {
+		const oldest = state.scores.keys().next();
+		if (oldest.done !== true) state.scores.delete(oldest.value);
+	}
+}
+/**
+* Mark one seq as LLM-recertified low relevance (a suggestion for later
+* history-aggressiveness decisions, consumed by nothing in this round).
+* Bounded at {@link ADVISOR_RECERTIFIED_LIMIT} with the same LRU eviction.
+*/
+function recordRecertified(state, seq, turn) {
+	state.recertified.delete(seq);
+	state.recertified.set(seq, turn);
+	if (state.recertified.size > 64) {
+		const oldest = state.recertified.keys().next();
+		if (oldest.done !== true) state.recertified.delete(oldest.value);
+	}
+}
+/**
+* Drop every cached artifact that depends on the task semantics: a changed
+* todo version invalidates the summary and makes all eligible candidates
+* rescore-worthy (the watermark alone would otherwise hide them).
+*/
+function invalidateOnTaskChange(state, todoVersion) {
+	if (state.todoVersion === todoVersion) return false;
+	state.todoVersion = todoVersion;
+	state.summary = void 0;
+	state.lastSummaryTurn = -1;
+	return true;
+}
+//#endregion
+export { DEFAULT_CUSTOM_COMPRESSION_POLICY as C, COMPRESSION_PROFILES as D, deepFreeze as E, CustomCompressionPolicySchema as S, assertNever as T, isCompressionProfile as _, registerReviewPruner as a, resolveConfig as b, ReviewQueue as c, ContextCompressionSettingsSchema as d, DEFAULTS as f, codePointLength as g, charsToTokens as h, recordScore as i, AUTO_COMPACT_THRESHOLD_LIMITS as l, charsForTokens as m, invalidateOnTaskChange as n, resolveReviewPruner as o, PRUNE_MARKER as p, recordRecertified as r, sharedReviewStore as s, getAdvisorState as t, CONTEXT_COMPRESSION_SETTINGS_NAMESPACE as u, isValidAutoCompactThresholdPercent as v, resolveCustomPolicy as w, resolvePolicy as x, parseContextCompressionSettings as y };

package/packages/selector/lib/client.d.ts

@@ -89,6 +89,13 @@ interface PresetOptionsSettings {
   readonly reviewTimeoutTurns?: number;
   readonly cacheHitDiscountAlpha?: number;
   readonly reviewHighImpactTokens?: number;
+  /** Advisory advisor channel; `''` (the default) keeps the advisor off. */
+  readonly advisorMode?: '' | 'host' | 'direct';
+  readonly advisorTimeoutMs?: number;
+  readonly advisorRefreshTurns?: number;
+  readonly advisorScoreThreshold?: number;
+  readonly advisorSampleLimit?: number;
+  readonly advisorMinTokens?: number;
 }
 /** Durable settings section owned by this package. */
 interface ContextCompressionSettings {

package/packages/selector/lib/client.js

@@ -82,7 +82,13 @@ window.__ModuleLoader__.load({
 				"reviewMode",
 				"reviewTimeoutTurns",
 				"cacheHitDiscountAlpha",
-				"reviewHighImpactTokens"
+				"reviewHighImpactTokens",
+				"advisorMode",
+				"advisorTimeoutMs",
+				"advisorRefreshTurns",
+				"advisorScoreThreshold",
+				"advisorSampleLimit",
+				"advisorMinTokens"
 			]);
 			if (Object.keys(value).some((key) => !allowed.has(key))) return void 0;
 			for (const key of [
@@ -97,6 +103,8 @@ window.__ModuleLoader__.load({
 			}
 			const estimatorMode = value.estimatorMode;
 			if (estimatorMode !== void 0 && estimatorMode !== "" && estimatorMode !== "host" && estimatorMode !== "direct") return;
+			const advisorMode = value.advisorMode;
+			if (advisorMode !== void 0 && advisorMode !== "" && advisorMode !== "host" && advisorMode !== "direct") return;
 			for (const key of [
 				"estimatorProvider",
 				"estimatorModel",
@@ -114,6 +122,16 @@ window.__ModuleLoader__.load({
 			if (cacheHitDiscountAlpha !== void 0 && (typeof cacheHitDiscountAlpha !== "number" || !Number.isFinite(cacheHitDiscountAlpha) || cacheHitDiscountAlpha <= 0 || cacheHitDiscountAlpha >= 1)) return;
 			const reviewHighImpactTokens = value.reviewHighImpactTokens;
 			if (reviewHighImpactTokens !== void 0 && (typeof reviewHighImpactTokens !== "number" || !Number.isSafeInteger(reviewHighImpactTokens) || reviewHighImpactTokens < 0)) return;
+			const advisorTimeoutMs = value.advisorTimeoutMs;
+			if (advisorTimeoutMs !== void 0 && (typeof advisorTimeoutMs !== "number" || !Number.isSafeInteger(advisorTimeoutMs) || advisorTimeoutMs < 100 || advisorTimeoutMs > 6e4)) return;
+			const advisorRefreshTurns = value.advisorRefreshTurns;
+			if (advisorRefreshTurns !== void 0 && (typeof advisorRefreshTurns !== "number" || !Number.isSafeInteger(advisorRefreshTurns) || advisorRefreshTurns < 1)) return;
+			const advisorScoreThreshold = value.advisorScoreThreshold;
+			if (advisorScoreThreshold !== void 0 && (typeof advisorScoreThreshold !== "number" || !Number.isFinite(advisorScoreThreshold) || advisorScoreThreshold <= 0 || advisorScoreThreshold >= 1)) return;
+			const advisorSampleLimit = value.advisorSampleLimit;
+			if (advisorSampleLimit !== void 0 && (typeof advisorSampleLimit !== "number" || !Number.isSafeInteger(advisorSampleLimit) || advisorSampleLimit < 1 || advisorSampleLimit > 64)) return;
+			const advisorMinTokens = value.advisorMinTokens;
+			if (advisorMinTokens !== void 0 && (typeof advisorMinTokens !== "number" || !Number.isSafeInteger(advisorMinTokens) || advisorMinTokens < 1)) return;
 			const decoded = {};
 			if (value.dedupeToolResults !== void 0) decoded.dedupeToolResults = value.dedupeToolResults;
 			if (value.summaryLocator !== void 0) decoded.summaryLocator = value.summaryLocator;
@@ -129,6 +147,12 @@ window.__ModuleLoader__.load({
 			if (reviewTimeoutTurns !== void 0) decoded.reviewTimeoutTurns = reviewTimeoutTurns;
 			if (cacheHitDiscountAlpha !== void 0) decoded.cacheHitDiscountAlpha = cacheHitDiscountAlpha;
 			if (reviewHighImpactTokens !== void 0) decoded.reviewHighImpactTokens = reviewHighImpactTokens;
+			if (advisorMode !== void 0) decoded.advisorMode = advisorMode;
+			if (advisorTimeoutMs !== void 0) decoded.advisorTimeoutMs = advisorTimeoutMs;
+			if (advisorRefreshTurns !== void 0) decoded.advisorRefreshTurns = advisorRefreshTurns;
+			if (advisorScoreThreshold !== void 0) decoded.advisorScoreThreshold = advisorScoreThreshold;
+			if (advisorSampleLimit !== void 0) decoded.advisorSampleLimit = advisorSampleLimit;
+			if (advisorMinTokens !== void 0) decoded.advisorMinTokens = advisorMinTokens;
 			return decoded;
 		}
 		/**
@@ -1544,7 +1568,13 @@ window.__ModuleLoader__.load({
 			"reviewMode",
 			"reviewTimeoutTurns",
 			"cacheHitDiscountAlpha",
-			"reviewHighImpactTokens"
+			"reviewHighImpactTokens",
+			"advisorMode",
+			"advisorTimeoutMs",
+			"advisorRefreshTurns",
+			"advisorScoreThreshold",
+			"advisorSampleLimit",
+			"advisorMinTokens"
 		];
 		/**
 		* Plan the path ops one patch needs against the section currently stored.
@@ -1768,7 +1798,7 @@ window.__ModuleLoader__.load({
 					}
 				};
 				pull();
-				let unsubscribe = () => {};
+				let unsubscribe;
 				try {
 					unsubscribe = scope.subscribe(pull);
 				} catch {

package/packages/selector/lib/index.d.ts

@@ -24,6 +24,13 @@ interface Config {
    * transport and simply never appears.
    */
   reviewQueueRoute?: boolean;
+  /**
+   * Register the advisory advisor's read-only HTTP report route (decay
+   * figure, task summary, score distribution). Same Bundle opt-in semantics
+   * as `reviewQueueRoute`; the advisor itself stays off until the user turns
+   * it on through the `presetOptions.advisor*` settings keys.
+   */
+  advisorReportRoute?: boolean;
 }
 /** Loader validation for the standalone Bundle opt-in. */
 declare const Config: z<Config>;

package/packages/selector/lib/index.js

@@ -1,4 +1,4 @@
-import { n as CONTEXT_COMPRESSION_SETTINGS_NAMESPACE, r as ContextCompressionSettingsSchema } from "./config.js";
+import { d as ContextCompressionSettingsSchema, o as resolveReviewPruner, t as getAdvisorState, u as CONTEXT_COMPRESSION_SETTINGS_NAMESPACE } from "./advisor-state.js";
 import z from "@deepseek-ai/schemastery";
 import "@deepseek-ai/dsh-settings";
 import { AsyncLocalStorage } from "node:async_hooks";
@@ -459,9 +459,20 @@ const CONTEXT_COMPRESSION_NAMESPACE = CONTEXT_COMPRESSION_SETTINGS_NAMESPACE;
 const ESTIMATOR_CATALOG_ROUTES = ["/endpoint/dsh-context-compression-improved/estimator-catalog", "/api/dsh-context-compression-improved/estimator-catalog"];
 const REVIEW_QUEUE_ROUTES = ["/endpoint/dsh-context-compression-improved/review-queue", "/api/dsh-context-compression-improved/review-queue"];
 const REVIEW_DECIDE_ROUTES = ["/endpoint/dsh-context-compression-improved/review-decide", "/api/dsh-context-compression-improved/review-decide"];
+const ADVISOR_REPORT_ROUTES = ["/endpoint/dsh-context-compression-improved/advisor-report", "/api/dsh-context-compression-improved/advisor-report"];
+/**
+* Resolve the review pipeline for the top-level routes.
+*
+* A top-level `toolResultPruner` service wins when a deployment actually mounts
+* one, but in production every pruner lives inside an agent preset's isolated
+* group, so the registry is the path that resolves. Without the fallback the
+* queue route answered 503 "review pipeline unavailable" on every request while
+* the review pipeline itself was running normally.
+*/
 function reviewPrunerOf(readService) {
 	const candidate = readService("toolResultPruner");
-	return typeof candidate?.listReviewProposals === "function" && typeof candidate?.decideReviewProposal === "function" ? candidate : void 0;
+	if (typeof candidate?.listReviewProposals === "function" && typeof candidate?.decideReviewProposal === "function") return candidate;
+	return resolveReviewPruner();
 }
 function sessionFor(readService, sessionId) {
 	const agents = readService("agents");
@@ -684,6 +695,102 @@ function registerReviewQueueRoutes(ctx) {
 	log("warn", "context-compression webServer not active yet — review routes pending: %s", REVIEW_QUEUE_ROUTES.join(", "));
 }
 /**
+* Serve the advisory advisor's read-only report route (same registration
+* skeleton as the review routes):
+*
+* `GET .../advisor-report?sessionId=…` → the session's prefix-decay figure,
+* the todolist-bound task summary, and the score distribution. Content-free
+* by construction: task semantics are LLM-derived summaries, never message
+* text, and no score reason or candidate preview is ever returned.
+* Unknown session → 404; no agents service → 503. A session whose advisor
+* never ran reports nulls and empty arrays, not an error.
+*/
+function registerAdvisorReportRoute(ctx) {
+	const readService = (name) => {
+		try {
+			return ctx.get(name);
+		} catch {
+			return;
+		}
+	};
+	const log = (level, message, ...args) => {
+		console[level](message, ...args);
+	};
+	const getHandler = (req, res) => {
+		if (typeof readService("agents")?.get !== "function") {
+			reviewJson(res, 503, {
+				ok: false,
+				error: "advisor report unavailable"
+			});
+			return;
+		}
+		let sessionId = "";
+		try {
+			sessionId = new URL(String(req.url ?? ""), "http://localhost").searchParams.get("sessionId") ?? "";
+		} catch {}
+		if (sessionId === "") {
+			reviewJson(res, 400, {
+				ok: false,
+				error: "sessionId is required"
+			});
+			return;
+		}
+		const session = sessionFor(readService, sessionId);
+		if (session === void 0) {
+			reviewJson(res, 404, {
+				ok: false,
+				error: "unknown session"
+			});
+			return;
+		}
+		const state = getAdvisorState(session);
+		reviewJson(res, 200, {
+			ok: true,
+			sessionId,
+			advisor: {
+				summary: state.summary ?? null,
+				decay: state.lastDecay?.decay ?? null,
+				weightedChars: state.lastDecay?.weightedChars ?? null,
+				decayTurn: state.lastDecay?.turn ?? null,
+				scores: [...state.scores].map(([seq, entry]) => ({
+					seq,
+					score: entry.score,
+					turn: entry.turn
+				})),
+				lowRelevanceSeqs: [...state.recertified.keys()]
+			}
+		});
+	};
+	const register = (webServer) => {
+		const disposers = [...ADVISOR_REPORT_ROUTES].map((path) => ({
+			path,
+			handler: getHandler
+		})).map((entry) => webServer.register({
+			kind: "exact",
+			path: entry.path,
+			handler: entry.handler
+		})).filter((off) => typeof off === "function");
+		ctx.effect(() => () => {
+			for (const off of disposers) off();
+		}, "contextCompressionSelector.advisor report route");
+		log("info", "context-compression advisor report route registered: %s", ADVISOR_REPORT_ROUTES.join(", "));
+	};
+	const active = asWebServer(readService("webServer"));
+	if (active !== void 0) {
+		register(active);
+		return;
+	}
+	ctx.inject(["webServer"], (injected) => {
+		const webServer = asWebServer(injected.webServer);
+		if (webServer === void 0) {
+			log("warn", "context-compression webServer exposes no register() — advisor report route not registered");
+			return;
+		}
+		register(webServer);
+	});
+	log("warn", "context-compression webServer not active yet — advisor report route pending: %s", ADVISOR_REPORT_ROUTES.join(", "));
+}
+/**
 * The one service the catalog route actually needs. `llm` and
 * `agentDefaultModel` are payload enrichment the handler resolves per request,
 * never reasons to withhold the route.
@@ -787,7 +894,8 @@ const SHARED_SETTINGS = Symbol.for("dsh-context-compression-improved/settings-re
 const Config = z.object({
 	presetOverlay: z.boolean().default(false),
 	estimatorCatalogRoute: z.boolean().default(false),
-	reviewQueueRoute: z.boolean().default(false)
+	reviewQueueRoute: z.boolean().default(false),
+	advisorReportRoute: z.boolean().default(false)
 });
 /** Register the persisted default read by the currently mounted root pruner. */
 function apply(ctx, config = {}) {
@@ -797,6 +905,7 @@ function apply(ctx, config = {}) {
 		});
 		if (config.estimatorCatalogRoute === true) registerEstimatorCatalogRoute(ctx);
 		if (config.reviewQueueRoute === true) registerReviewQueueRoutes(ctx);
+		if (config.advisorReportRoute === true) registerAdvisorReportRoute(ctx);
 		if (config.presetOverlay !== true) return;
 		ctx.inject(["agentPresets"], (presetsCtx) => {
 			const installation = decorateAgentPresets(presetsCtx.agentPresets, {