dsh-workbuddy-xdpool 1.2.0 → 1.4.0

package/lib/index.js

@@ -31,6 +31,8 @@ const MODELS_CATALOG_PATH = "/v2/enterprises/personal/models";
 const GLOBAL_CONFIG_PATH = "/v3/config";
 const JSON_TIMEOUT_MS = 3e4;
 const ERROR_BODY_LIMIT = 4096;
+/** Cap on the reassembled compaction reply, guarding against a runaway stream. */
+const COMPLETION_TEXT_LIMIT = 65536;
 /** Insufficient-credit markers, ASCII lowercase plus the original Chinese. */
 const HARD_CREDIT_MARKERS = [
 	"insufficient credit",
@@ -49,8 +51,31 @@ const HARD_CREDIT_MARKERS = [
 	"额度用尽",
 	"没有积分"
 ];
-/** Session-invalidation markers that mean "sign in again in the WorkBuddy app". */
-const SESSION_DEAD_MARKERS = ["Offline user session not found", "12153"];
+/** Session-invalidation markers that mean "this credential is dead; use another".
+*  Kept alongside the HTTP-status rule in `classifyUpstreamError`: the status is
+*  enough for a direct 401/403, but some failures arrive wrapped in a 200
+*  envelope or a 4xx the gateway words differently. Adding the English and
+*  Chinese phrasings the upstream actually uses keeps those recoverable too —
+*  an unmatched one fell through to `client`, which is terminal in the shim
+*  and pinned the pool to the first account (the "API 密钥无效" bug). */
+const SESSION_DEAD_MARKERS = [
+	"Offline user session not found",
+	"12153",
+	"api key is invalid",
+	"invalid api key",
+	"invalid_api_key",
+	"api密钥无效",
+	"密钥无效",
+	"无效的密钥",
+	"unauthorized",
+	"token expired",
+	"token is invalid",
+	"login expired",
+	"please login",
+	"未登录",
+	"登录已失效",
+	"重新登录"
+];
 /**
 * Markers for "already checked in today".
 *
@@ -223,12 +248,82 @@ function envelopeError(status, envelope) {
 	return /* @__PURE__ */ new Error(`workbuddy upstream ${kind} (http ${status}): ${envelope.msg.slice(0, 160)}`);
 }
 /**
+* Read an OpenAI-style SSE chat stream and concatenate the assistant text.
+*
+* The upstream always streams (`stream: true` is forced on every chat body),
+* so a non-streaming internal call has to reassemble the deltas itself. Only
+* `choices[0].delta.content` is collected; reasoning deltas are dropped
+* because a compaction summary needs the final answer, not the scratchpad.
+*/
+async function readCompletionText(body) {
+	const decoder = new TextDecoder();
+	const reader = body.getReader();
+	let buffer = "";
+	let text = "";
+	try {
+		for (;;) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			buffer += decoder.decode(value, { stream: true });
+			let split = buffer.indexOf("\n\n");
+			while (split !== -1) {
+				const frame = buffer.slice(0, split);
+				buffer = buffer.slice(split + 2);
+				text += contentOfFrame(frame);
+				if (text.length > COMPLETION_TEXT_LIMIT) return text.slice(0, COMPLETION_TEXT_LIMIT);
+				split = buffer.indexOf("\n\n");
+			}
+		}
+		if (buffer.trim() !== "") text += contentOfFrame(buffer);
+	} finally {
+		reader.releaseLock?.();
+	}
+	return text;
+}
+/** Pull `choices[0].delta.content` (or a non-streaming `message.content`) out of one SSE frame. */
+function contentOfFrame(frame) {
+	let out = "";
+	for (const rawLine of frame.split(/\r?\n/u)) {
+		const line = rawLine.trim();
+		if (!line.startsWith("data:")) continue;
+		const payload = line.slice(5).trim();
+		if (payload === "" || payload === "[DONE]") continue;
+		let parsed;
+		try {
+			parsed = JSON.parse(payload);
+		} catch {
+			continue;
+		}
+		if (typeof parsed !== "object" || parsed === null) continue;
+		const choices = parsed["choices"];
+		if (!Array.isArray(choices) || choices.length === 0) continue;
+		const choice = choices[0];
+		const delta = choice["delta"];
+		if (typeof delta === "object" && delta !== null) {
+			const content = delta["content"];
+			if (typeof content === "string") out += content;
+		}
+		const message = choice["message"];
+		if (typeof message === "object" && message !== null) {
+			const content = message["content"];
+			if (typeof content === "string") out += content;
+		}
+		const data = parsed["data"];
+		if (typeof data === "object" && data !== null) {
+			const inner = data["content"];
+			if (typeof inner === "string") out += inner;
+		}
+	}
+	return out;
+}
+/**
 * Classify an upstream failure from its HTTP status and body excerpt.
 * Body markers win over status, because the upstream reuses 400/200 for
 * several distinct conditions.
 */
 function classifyUpstreamError(status, body) {
 	if (status === 402) return "hard_credit";
+	if (status === 401 || status === 403) return "session_dead";
 	const lower = body.toLowerCase();
 	for (const marker of HARD_CREDIT_MARKERS) if (lower.includes(marker.toLowerCase()) || body.includes(marker)) return "hard_credit";
 	for (const marker of SESSION_DEAD_MARKERS) if (body.includes(marker)) return "session_dead";
@@ -696,6 +791,51 @@ var WorkBuddyUpstreamClient = class {
 		}
 		return JSON.stringify(obj);
 	}
+	/**
+	* Parse a raw OpenAI chat body without normalising it.
+	*
+	* The compactor needs the message array as objects, while `chatStream` only
+	* accepts the serialised string form.
+	*/
+	parseChatBody(raw) {
+		let body;
+		try {
+			body = JSON.parse(raw);
+		} catch {
+			return;
+		}
+		if (typeof body !== "object" || body === null || Array.isArray(body)) return void 0;
+		return body;
+	}
+	/** Re-serialise `base` with a rewritten `messages` array, still normalised. */
+	buildChatBody(base, messages) {
+		return this.prepareChatBody(JSON.stringify({
+			...base,
+			messages
+		}));
+	}
+	/**
+	* Run one NON-streaming completion and return the assistant text.
+	*
+	* Used only for internal compaction (summarising dropped turns). The chat
+	* endpoint itself always streams, so this reassembles the SSE frames into a
+	* single string. Throws on any failure: the compactor then falls back to
+	* plain truncation rather than failing the user's turn.
+	*/
+	async completeChat(credential, prepared, signal) {
+		const response = await this.fetchImpl(`${chatBase(credential)}/v2/chat/completions`, {
+			method: "POST",
+			headers: chatHeaders(credential),
+			body: prepared,
+			...signal === void 0 ? {} : { signal }
+		});
+		if (!response.ok) {
+			const text = (await response.text().catch(() => "")).slice(0, ERROR_BODY_LIMIT);
+			throw new Error(`compaction upstream http ${response.status}: ${text}`);
+		}
+		if (response.body === null) throw new Error("compaction upstream returned no body");
+		return await readCompletionText(response.body);
+	}
 	/** Forward one chat completion. Never throws for upstream failures. */
 	async chatStream(credential, prepared, signal) {
 		let response;
@@ -3031,6 +3171,16 @@ function dayKey(date) {
 	return `${date.getFullYear()}-${month}-${day}`;
 }
 /**
+* The scheduled SLOT `date` falls in, as `YYYY-MM-DDTHH`.
+*
+* The per-job run guard keys on this instead of the date, so a job configured
+* for several hours runs in each of them while a second tick inside the same
+* hour is still refused.
+*/
+function slotKey(date) {
+	return `${dayKey(date)}T${String(date.getHours()).padStart(2, "0")}`;
+}
+/**
 * Whether `now`'s local hour is one of `hours`.
 *
 * The reference panel computes a `nextFire` instant and sleeps until it; this
@@ -3135,7 +3285,7 @@ var WorkBuddyScheduler = class {
 		this.reportHours = options.reportHours ?? [10];
 		this.taskHours = options.taskHours ?? [11];
 		this.streakHours = options.streakHours ?? [12];
-		this.travelHours = options.travelHours ?? [12];
+		this.travelHours = options.travelHours ?? [9, 21];
 	}
 	/** Apply a new configuration; safe to call while running. */
 	/**
@@ -3213,7 +3363,7 @@ var WorkBuddyScheduler = class {
 	async runNow(kind, force = false) {
 		const today = dayKey(this.now());
 		const state = this.states[kind];
-		if (!force && state.lastRunDate === today) return { ...state };
+		if (!force && state.lastRunSlot === slotKey(this.now())) return { ...state };
 		this.busy = true;
 		try {
 			await this.runJob(kind, today);
@@ -3308,10 +3458,11 @@ var WorkBuddyScheduler = class {
 		this.busy = true;
 		try {
 			const now = this.now();
+			const slot = slotKey(now);
 			const today = dayKey(now);
 			for (const kind of JOB_KINDS) {
 				if (this.stopped) return;
-				if (this.states[kind].lastRunDate === today) continue;
+				if (this.states[kind].lastRunSlot === slot) continue;
 				if (!isFireHour(now, this.hoursOf(kind))) continue;
 				await this.runJob(kind, today);
 			}
@@ -3409,6 +3560,8 @@ var WorkBuddyScheduler = class {
 		let credit = 0;
 		let energy = 0;
 		let claimed = 0;
+		const detail = [];
+		let progressNote;
 		const accounts = this.accountsInOrder();
 		if (kind === "tasks") await this.sendEventChains(accounts);
 		for (let index = 0; index < accounts.length; index++) {
@@ -3421,7 +3574,10 @@ var WorkBuddyScheduler = class {
 						try {
 							const claim = await this.client.claimDailyCheckin(account.credential);
 							this.recordEarnings(account.id, today, { checkinCredit: claim.credit });
-							if (claim.credit > 0) this.logger.info?.(`automation checkin ${account.label}: +${claim.credit} credit`);
+							if (claim.credit > 0) {
+								if (claim.credit > 0) detail.push(`签到 +${claim.credit}`);
+								this.logger.info?.(`automation checkin ${account.label}: +${claim.credit} credit`);
+							}
 						} catch (error) {
 							if (!isAlreadyCheckin(error)) throw error;
 							this.logger.info?.(`automation checkin ${account.label}: already done today`);
@@ -3437,6 +3593,7 @@ var WorkBuddyScheduler = class {
 						credit += result.credit;
 						energy += result.energy;
 						claimed += result.claimed;
+						detail.push(...result.titles);
 						this.claimableSeen += result.claimableCount;
 						this.recordEarnings(account.id, today, {
 							credit: result.credit,
@@ -3446,9 +3603,11 @@ var WorkBuddyScheduler = class {
 						this.logger.info?.(`automation tasks ${account.label}: ${result.claimed} claimed (+${result.credit} credit, +${result.energy} energy, ${result.claimableCount} claimable seen)`);
 						break;
 					}
-					case "streak":
-						await this.redeemStreak(account);
+					case "streak": {
+						const progress = await this.redeemStreak(account);
+						if (progress !== void 0) progressNote = progress;
 						break;
+					}
 					case "travel": await this.runTravel(account);
 				}
 				ok++;
@@ -3459,6 +3618,7 @@ var WorkBuddyScheduler = class {
 			if (index < accounts.length - 1 && this.delayMs > 0 && !this.stopped) await sleep(this.delayMs);
 		}
 		const state = this.states[kind];
+		state.lastRunSlot = slotKey(this.now());
 		state.lastRunDate = today;
 		state.lastRunAtMs = this.now().getTime();
 		state.ok = ok;
@@ -3467,6 +3627,8 @@ var WorkBuddyScheduler = class {
 		state.energy = energy;
 		state.claimed = claimed;
 		state.message = this.summarise(kind, ok, failed, claimed, credit, energy);
+		state.detail = detail;
+		state.progress = progressNote;
 		this.logger.info?.(`automation ${accountWord}: ${state.message}`);
 	}
 	/** Compose the one-line summary shown on the card. */
@@ -3669,6 +3831,7 @@ var WorkBuddyScheduler = class {
 		let credit = 0;
 		let energy = 0;
 		let claimed = 0;
+		const titles = [];
 		for (const task of claimable) {
 			if (this.stopped) break;
 			const reward = await this.client.claimTaskReward(credential, task.taskCode);
@@ -3676,6 +3839,7 @@ var WorkBuddyScheduler = class {
 			energy += reward.energy;
 			if (reward.credit > 0 || reward.energy > 0) {
 				claimed++;
+				titles.push(task.title);
 				this.logger.info?.(`automation claim ${account.label}: ${task.title} +${reward.credit}c +${reward.energy}e`);
 			} else this.logger.info?.(`automation claim ${account.label}: ${task.taskCode} already claimed`);
 			if (this.delayMs > 0 && !this.stopped) await sleep(this.delayMs);
@@ -3684,7 +3848,8 @@ var WorkBuddyScheduler = class {
 			claimed,
 			credit,
 			energy,
-			claimableCount: claimable.length
+			claimableCount: claimable.length,
+			titles
 		};
 	}
 	/**
@@ -3724,6 +3889,11 @@ var WorkBuddyScheduler = class {
 			}
 			if (this.delayMs > 0 && !this.stopped) await sleep(this.delayMs);
 		}
+		const pendingTier = status.tiers.find((tier) => tier.status === "locked");
+		if (pendingTier !== void 0) {
+			const remaining = Math.max(0, pendingTier.days - status.days);
+			return remaining > 0 ? `${pendingTier.tier} in ${remaining}d` : `${pendingTier.tier} ready`;
+		}
 	}
 	/**
 	* One trip through the buddy travel loop for an account.
@@ -3768,6 +3938,286 @@ var WorkBuddyScheduler = class {
 	}
 };
 //#endregion
+//#region src/context-budget.ts
+/** Rough character-per-token ratio. CJK is ~1 token/char, latin ~1/4. */
+const CHARS_PER_TOKEN_LATIN = 4;
+const CHARS_PER_TOKEN_CJK = 1;
+/** Fixed per-message overhead the chat template adds (role markers etc.). */
+const PER_MESSAGE_TOKEN_OVERHEAD = 4;
+/** Every image/tool part costs at least this much once decoded. */
+const PER_PART_TOKEN_FLOOR = 16;
+/**
+* Estimate the token cost of one message's `content`.
+*
+* Deliberately conservative (over-estimates) so we compact slightly early
+* rather than discovering the overrun upstream.
+*/
+function estimateContentTokens(content) {
+	if (content === null || content === void 0) return 0;
+	if (typeof content === "string") return estimateTextTokens(content);
+	if (typeof content === "number" || typeof content === "boolean") return PER_PART_TOKEN_FLOOR;
+	if (Array.isArray(content)) {
+		let total = 0;
+		for (const part of content) total += estimateContentTokens(part);
+		return total;
+	}
+	if (typeof content === "object") {
+		const record = content;
+		let total = PER_PART_TOKEN_FLOOR;
+		for (const key of [
+			"text",
+			"image_url",
+			"input",
+			"content"
+		]) if (key in record) total += estimateContentTokens(record[key]);
+		if (total === PER_PART_TOKEN_FLOOR) total += estimateTextTokens(safeStringify(record));
+		return total;
+	}
+	return 0;
+}
+/** Estimate tokens for a plain string, accounting for CJK density. */
+function estimateTextTokens(text) {
+	if (text === "") return 0;
+	let cjk = 0;
+	for (const char of text) if (isCjk(char.codePointAt(0) ?? 0)) cjk += 1;
+	const latin = text.length - cjk;
+	return Math.ceil(cjk / CHARS_PER_TOKEN_CJK + latin / CHARS_PER_TOKEN_LATIN);
+}
+function isCjk(code) {
+	return code >= 12288 && code <= 12351 || code >= 12352 && code <= 12543 || code >= 13312 && code <= 19903 || code >= 19968 && code <= 40959 || code >= 63744 && code <= 64255 || code >= 65280 && code <= 65519 || code >= 131072 && code <= 191471;
+}
+function safeStringify(value) {
+	try {
+		return JSON.stringify(value) ?? "";
+	} catch {
+		return String(value);
+	}
+}
+/** Estimate the prompt cost of a whole message array. */
+function estimateMessagesTokens(messages) {
+	let total = 0;
+	for (const message of messages) {
+		total += PER_MESSAGE_TOKEN_OVERHEAD;
+		total += estimateContentTokens(message.content);
+		if (message["tool_calls"] !== void 0) total += estimateContentTokens(message["tool_calls"]);
+		if (message["name"] !== void 0) total += estimateTextTokens(String(message["name"]));
+	}
+	return total;
+}
+/** True when `role` carries instructions that must survive compaction. */
+function isPinnedRole(role) {
+	return role === "system" || role === "developer";
+}
+/**
+* Drop the oldest non-pinned messages until the estimate fits `budget`.
+*
+* Pinned (system/developer) messages and the newest `keepRecent` messages are
+* never dropped here — if those alone overrun the budget, the caller must fall
+* back to summarisation or give up.
+*/
+function compactMessages(messages, options) {
+	const keepRecent = Math.max(1, options.keepRecent ?? 4);
+	const estimate = estimateMessagesTokens(messages);
+	if (estimate <= options.budget) return {
+		messages: [...messages],
+		dropped: [],
+		tokens: estimate,
+		changed: false
+	};
+	const pinned = [];
+	const body = [];
+	for (const message of messages) if (isPinnedRole(message.role)) pinned.push(message);
+	else body.push(message);
+	const keep = Math.min(keepRecent, body.length);
+	const tail = body.slice(body.length - keep);
+	const head = body.slice(0, body.length - keep);
+	let dropCount = 0;
+	let candidate = [
+		...pinned,
+		...head,
+		...tail
+	];
+	let total = estimateMessagesTokens(candidate);
+	while (total > options.budget && dropCount < head.length) {
+		dropCount += 1;
+		candidate = [
+			...pinned,
+			...head.slice(dropCount),
+			...tail
+		];
+		total = estimateMessagesTokens(candidate);
+	}
+	const dropped = head.slice(0, dropCount);
+	return {
+		messages: candidate,
+		dropped,
+		tokens: total,
+		changed: dropCount > 0
+	};
+}
+/**
+* Drop the oldest messages, including pinned ones, as a last resort.
+*
+* Used when even a summary cannot bring the prompt under budget (for example a
+* single enormous pasted document). The newest message always survives.
+*/
+function hardTruncate(messages, budget) {
+	if (messages.length === 0) return {
+		messages: [],
+		dropped: [],
+		tokens: 0,
+		changed: false
+	};
+	let start = 0;
+	let candidate = [...messages];
+	let total = estimateMessagesTokens(candidate);
+	while (total > budget && start < messages.length - 1) {
+		start += 1;
+		candidate = messages.slice(start);
+		total = estimateMessagesTokens(candidate);
+	}
+	return {
+		messages: candidate,
+		dropped: messages.slice(0, start),
+		tokens: total,
+		changed: start > 0
+	};
+}
+/** Instructions handed to the model when we ask it to compact a conversation. */
+const SUMMARIZE_INSTRUCTION = [
+	"You are compacting an ongoing conversation so it can continue without the original history.",
+	"Summarise the transcript below into a dense briefing for the next assistant turn.",
+	"Preserve, in this order of priority:",
+	"1. explicit user requirements, constraints and corrections;",
+	"2. decisions already made, and the reasoning behind them;",
+	"3. concrete facts: file paths, identifiers, commands, numbers, error messages;",
+	"4. unfinished work and the current blocker.",
+	"Drop pleasantries, repetition and superseded attempts.",
+	"Write the briefing only — no preamble, no markdown fence."
+].join("\n");
+/** Render a message array as plain text for the summarisation prompt. */
+function transcriptOf(messages) {
+	const lines = [];
+	for (const message of messages) {
+		const role = message.role === "" ? "unknown" : message.role;
+		lines.push(`### ${role}`);
+		lines.push(renderContent(message.content));
+		if (message["tool_calls"] !== void 0) lines.push(renderContent(message["tool_calls"]));
+	}
+	return lines.join("\n");
+}
+function renderContent(content) {
+	if (content === null || content === void 0) return "";
+	if (typeof content === "string") return content;
+	if (Array.isArray(content)) return content.map((part) => renderContent(part)).filter((text) => text !== "").join("\n");
+	if (typeof content === "object") {
+		const record = content;
+		for (const key of [
+			"text",
+			"content",
+			"input"
+		]) if (typeof record[key] === "string") return record[key];
+		if (record["type"] !== void 0 && typeof record["type"] === "string") return `[${record["type"]}]`;
+		return safeStringify(record);
+	}
+	return String(content);
+}
+/** Build the synthetic system message that carries a compaction summary. */
+function summaryMessage(summary) {
+	return {
+		role: "system",
+		content: [
+			"The earlier part of this conversation was compacted to fit the model context window.",
+			"Briefing produced from the dropped turns:",
+			"",
+			summary.trim()
+		].join("\n")
+	};
+}
+/**
+* Compact `messages` to `budget`, summarising the dropped turns when possible.
+*
+* The summary is requested with a *bounded* transcript so the compaction call
+* itself can never overrun the window: if the dropped turns are huge, only the
+* newest slice of them is summarised, and the oldest are noted as elided.
+*/
+async function compactWithSummary(messages, options, deps, signal) {
+	const first = compactMessages(messages, options);
+	if (!first.changed) return {
+		messages: first.messages,
+		tokens: first.tokens,
+		summary: void 0,
+		skipped: void 0
+	};
+	const summaryBudget = Math.max(256, Math.floor(options.budget / 4));
+	let toSummarize = first.dropped;
+	let elided = 0;
+	while (estimateMessagesTokens(toSummarize) > summaryBudget && toSummarize.length > 1) {
+		toSummarize = toSummarize.slice(1);
+		elided += 1;
+	}
+	let summary;
+	let skipped;
+	try {
+		const instruction = elided > 0 ? `${SUMMARIZE_INSTRUCTION}\n\nNote: the ${elided} oldest turn(s) were elided before this transcript.` : SUMMARIZE_INSTRUCTION;
+		const suffix = elided > 0 ? `\n(the ${elided} oldest turn(s) were elided)` : "";
+		const request = [{
+			role: "system",
+			content: instruction
+		}, {
+			role: "user",
+			content: `${transcriptOf(toSummarize)}${suffix}`
+		}];
+		const text = await deps.complete(request, signal);
+		if (text.trim() !== "") summary = text.trim();
+		else skipped = "summariser returned an empty summary";
+	} catch (error) {
+		skipped = `summarisation failed: ${String(error)}`;
+	}
+	if (summary === void 0) return {
+		messages: first.messages,
+		skipped,
+		tokens: first.tokens
+	};
+	const withSummary = injectSummary(first.messages, summary);
+	if (estimateMessagesTokens(withSummary) > options.budget) {
+		const truncated = hardTruncate(withSummary, options.budget);
+		return {
+			messages: truncated.messages,
+			summary,
+			tokens: truncated.tokens
+		};
+	}
+	return {
+		messages: withSummary,
+		summary,
+		tokens: estimateMessagesTokens(withSummary)
+	};
+}
+/**
+* Re-insert a summary as: pinned instructions → summary → surviving tail.
+*
+* Order matters. Pinned (system/developer) messages must stay ahead of the
+* summary so that a later synthetic system message can never override the
+* harness's own instructions; the tail follows so the newest exchange is the
+* last thing the model reads.
+*
+* `compacted` is always derived from `original` by `compactMessages`, so the
+* pinned messages it carries are exactly the originals — no need to re-add
+* them from `original`.
+*/
+function injectSummary(compacted, summary) {
+	const pinned = [];
+	const rest = [];
+	for (const message of compacted) if (isPinnedRole(message.role)) pinned.push(message);
+	else rest.push(message);
+	return [
+		...pinned,
+		summaryMessage(summary),
+		...rest
+	];
+}
+//#endregion
 //#region src/shim.ts
 /**
 * Loopback OpenAI-compatible endpoint with multi-account failover.
@@ -3846,7 +4296,8 @@ function writeOpenAIError(res, status, kind, message) {
 }
 /** True when an upstream failure body means the request overran the model's
 *  context window (OpenAI `context_length_exceeded`, WorkBuddy code 11115 /
-*  "input length too long"). Surfaced as a friendly hint, never auto-truncated. */
+*  "input length too long"). The shim answers it by compacting the conversation
+*  in place and retrying once; see `recoverFromContextOverrun`. */
 function isContextTooLong(body) {
 	if (body.includes("context_length_exceeded")) return true;
 	if (body.includes("input length too long")) return true;
@@ -4008,25 +4459,7 @@ function createWorkBuddyShim(options) {
 			tried.push(account.label);
 			const result = await client.chatStream(account.credential, prepared, controller.signal);
 			if (result.ok) {
-				logger?.info?.(`dsh-workbuddy-xdpool: served by ${account.label}`);
-				pool.noteServed(account.id);
-				refreshBalance(account);
-				res.writeHead(200, {
-					"Content-Type": "text/event-stream",
-					"Cache-Control": "no-cache",
-					"Connection": "keep-alive",
-					"X-Accel-Buffering": "no"
-				});
-				let sawDone = false;
-				const body = Readable.fromWeb(result.response.body);
-				body.on("data", (chunk) => {
-					if (chunk.includes("[DONE]")) sawDone = true;
-				});
-				body.on("error", (error) => {
-					logger?.warn("dsh-workbuddy-xdpool: upstream stream failed mid-flight", error);
-					if (!sawDone && res.writable) res.end("data: [DONE]\n\n");
-				});
-				body.pipe(res);
+				await serveSuccessfulStream(res, account, result, logger, refreshBalance, pool);
 				return;
 			}
 			last = {
@@ -4054,7 +4487,21 @@ function createWorkBuddyShim(options) {
 			return;
 		}
 		if (isContextTooLong(last.message)) {
-			writeOpenAIError(res, 400, "context_length_exceeded", `${modelId === void 0 ? "the conversation exceeds this model's context window" : `the conversation exceeds ${modelId}'s context window`}. Shorten the conversation, start a new chat, or pick a model with a larger window (e.g. hy4-preview).`);
+			const recovered = await recoverFromContextOverrun({
+				raw,
+				modelId,
+				controller,
+				region,
+				logger,
+				client,
+				pool,
+				maxAttempts
+			});
+			if (recovered.ok) {
+				await serveSuccessfulStream(res, recovered.account, recovered.result, logger, refreshBalance, pool);
+				return;
+			}
+			writeOpenAIError(res, 400, "context_length_exceeded", contextOverflowMessage(modelId, recovered.detail));
 			return;
 		}
 		writeOpenAIError(res, KIND_STATUS[last.kind], last.kind, `workbuddy upstream ${last.kind} (http ${last.status}) after ${tried.length} account(s) [${tried.join(" → ")}]: ${last.message.slice(0, 400)}`);
@@ -4070,6 +4517,168 @@ function createWorkBuddyShim(options) {
 		})
 	};
 }
+/**
+* Build the overflow message the Harness must recognize.
+*
+* This is deliberately NOT free-form prose. `dsh-compaction-basic` decides
+* whether to compact-and-retry by running the text that reaches it through
+* `isContextWindowExceededError()` (`@deepseek-ai/dsh-llm`), whose matcher
+* accepts only specific phrasings:
+*
+*   - `context_length_exceeded` / `context window exceeded`
+*   - `maximum context length`
+*   - `<input|prompt|request|messages> too large|long for ... context`
+*   - `<input|prompt|request> exceeds the ... context window`
+*
+* The obvious friendly sentence ("the conversation exceeds this model's
+* context window") matches NONE of them, and neither does the WorkBuddy
+* upstream's own "input length too long" / code 11115. Emitting either meant
+* the Harness saw an unclassifiable 400, skipped its recovery path, and
+* surfaced a dead turn — the bug this function exists to prevent.
+*
+* The leading clause carries the machine-matched wording; the trailing clause
+* is what a human reads. Keep both in sync with
+* `tests/context-overflow-contract.test.ts`.
+*/
+function contextOverflowMessage(modelId, detail = "") {
+	return `This model's maximum context length was exceeded: the prompt is too large for ${modelId === void 0 ? "the model" : `model ${modelId}`}, and the conversation could not be compacted in place${detail === "" ? "" : ` (${detail})`}. Compact the conversation, or start a new chat.`;
+}
+/**
+* Serve one already-successful upstream stream as an SSE response.
+*
+* Extracted so the context-overrun recovery path reuses the exact same
+* bookkeeping (noteServed + background balance refresh) as a first-try hit.
+*/
+async function serveSuccessfulStream(res, account, result, logger, refreshBalance, pool) {
+	logger?.info?.(`dsh-workbuddy-xdpool: served by ${account.label}`);
+	pool.noteServed(account.id);
+	refreshBalance(account);
+	res.writeHead(200, {
+		"Content-Type": "text/event-stream",
+		"Cache-Control": "no-cache",
+		"Connection": "keep-alive",
+		"X-Accel-Buffering": "no"
+	});
+	let sawDone = false;
+	const body = Readable.fromWeb(result.response.body);
+	body.on("data", (chunk) => {
+		if (chunk.includes("[DONE]")) sawDone = true;
+	});
+	body.on("error", (error) => {
+		logger?.warn("dsh-workbuddy-xdpool: upstream stream failed mid-flight", error);
+		if (!sawDone && res.writable) res.end("data: [DONE]\n\n");
+	});
+	body.pipe(res);
+}
+/**
+* Compact an over-long conversation and retry it once.
+*
+* Strategy, in order:
+*  1. drop the oldest turns, keeping system messages and the newest exchange;
+*  2. ask the model to summarise the dropped turns and splice that summary in;
+*  3. hard-truncate as a last resort.
+*
+* Returns `ok: false` only when even a truncated prompt still overran — the
+* caller then surfaces the original actionable 400.
+*/
+async function recoverFromContextOverrun(options) {
+	const { raw, modelId, controller, region, logger, client, pool, maxAttempts } = options;
+	const parsed = client.parseChatBody(raw);
+	if (parsed === void 0) return {
+		ok: false,
+		detail: "request body was not parseable JSON"
+	};
+	const rawMessages = parsed["messages"];
+	if (!Array.isArray(rawMessages)) return {
+		ok: false,
+		detail: "request carried no messages array"
+	};
+	const messages = rawMessages.filter((value) => typeof value === "object" && value !== null && !Array.isArray(value));
+	if (messages.length === 0) return {
+		ok: false,
+		detail: "request carried no usable messages"
+	};
+	const overrunTokens = estimateMessagesTokens(messages);
+	const budget = Math.max(512, Math.floor(overrunTokens / 2));
+	logger?.warn(`dsh-workbuddy-xdpool: context overrun on ${modelId ?? "(no model)"} (~${overrunTokens} tokens); compacting to ~${budget} and retrying once`);
+	let summary;
+	let compacted = messages;
+	let compactionDetail = "";
+	try {
+		const summariser = await pool.acquire(modelId, region);
+		if (summariser === void 0) compactionDetail = "no account available to summarise with";
+		else {
+			const outcome = await compactWithSummary(messages, {
+				budget,
+				keepRecent: 6
+			}, { complete: async (request, signal) => {
+				const body = client.buildChatBody({
+					...parsed,
+					stream: true,
+					max_tokens: Math.max(256, Math.floor(budget / 2))
+				}, request);
+				return await client.completeChat(summariser.credential, body, signal ?? controller.signal);
+			} }, controller.signal);
+			compacted = outcome.messages;
+			summary = outcome.summary;
+			if (outcome.skipped !== void 0) compactionDetail = outcome.skipped;
+		}
+	} catch (error) {
+		compactionDetail = `summarisation failed: ${String(error)}`;
+	}
+	if (estimateMessagesTokens(compacted) > budget) compacted = hardTruncate(compacted, budget).messages;
+	if (summary === void 0 && estimateMessagesTokens(compacted) >= overrunTokens) return {
+		ok: false,
+		detail: compactionDetail === "" ? "compaction could not reduce the prompt" : compactionDetail
+	};
+	const retryBody = client.buildChatBody(parsed, compacted);
+	const tried = [];
+	for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+		if (controller.signal.aborted) return {
+			ok: false,
+			detail: "client disconnected"
+		};
+		const account = await pool.acquire(modelId, region);
+		if (account === void 0) return {
+			ok: false,
+			detail: "no account available after compaction"
+		};
+		tried.push(account.label);
+		const result = await client.chatStream(account.credential, retryBody, controller.signal);
+		if (result.ok) {
+			logger?.info?.(`dsh-workbuddy-xdpool: recovered from context overrun on ${modelId ?? "(no model)"} (summarised: ${summary === void 0 ? "no" : "yes"})`);
+			return {
+				ok: true,
+				account,
+				result
+			};
+		}
+		if (isContextTooLong(result.message)) return {
+			ok: false,
+			detail: "prompt still exceeded the window after compaction"
+		};
+		if (result.kind === "session_dead") {
+			await pool.refreshAccount(account.id);
+			continue;
+		}
+		if (result.kind === "hard_credit") {
+			pool.penalizeExhausted(account.id);
+			continue;
+		}
+		if (result.kind === "soft_rate") {
+			pool.penalize(account.id, parseRateLimitReset(result.message), modelId);
+			continue;
+		}
+		return {
+			ok: false,
+			detail: `upstream ${result.kind} after compaction`
+		};
+	}
+	return {
+		ok: false,
+		detail: `no account served the compacted request (tried ${tried.length})`
+	};
+}
 //#endregion
 //#region src/status.ts
 /** Build the status document. Never throws. */