dsh-workbuddy-xdpool 1.0.1 → 1.2.0

package/lib/bin.js

@@ -1,4 +1,4 @@
-import { createHash } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { copyFile, mkdir, readFile, readdir, writeFile } from "node:fs/promises";
 import { homedir, platform } from "node:os";
 import { basename, join, resolve } from "node:path";
@@ -50,6 +50,15 @@ 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"];
 /**
+* Markers for "already checked in today".
+*
+* The upstream answers a non-zero business code (and HTTP 400) when the daily
+* check-in is repeated. That is an idempotent success, not a failure: the
+* reward for today is already collected. Matched against the message, since
+* the code varies by realm.
+*/
+const ALREADY_CHECKIN_MARKERS = ["已签到", "already"];
+/**
 * Hosts the international product answers on, once each has been stripped of a
 * leading label. The WorkBuddy AI desktop app signs in at `workbuddy.ai` (and
 * the desktop client itself lists `workbuddy.cc` alongside it); the CodeBuddy
@@ -123,6 +132,43 @@ function refreshHeaders(credential) {
 	if (credential.enterpriseId !== void 0 && credential.enterpriseId !== "") headers["X-Enterprise-Id"] = credential.enterpriseId;
 	return headers;
 }
+/** Desktop-client report endpoint and the UA it is fingerprinted by. */
+const DESKTOP_REPORT_PATH = "/v2/report";
+/** Theme-selection endpoint (Hp_Appearance). */
+const APPEARANCE_SET_PATH = "/v2/user-asset/appearance/set";
+/** Expert marketplace listing, used to look up REAL expert ids. */
+const MARKET_EXPERT_LIST_PATH = "/portal/operation-platform/market/expert/list";
+/** Cap on how long a chain waits for a conversation answer. */
+const CHAT_TIMEOUT_MS = 9e4;
+/** How far into an SSE stream to look for the server's request id. */
+const SSE_SCAN_LIMIT = 1 << 20;
+/** Server request ids look like `cmb-<32 hex>` or a bare 32 hex string. */
+const SERVER_ID_PATTERN = /"id"\s*:\s*"((?:cmb-)?[0-9a-f]{32})"/;
+const DESKTOP_TASK_UA = "WorkBuddy/5.5.6 WorkBuddy/5.5.6 CLI/2.137.1";
+/**
+* Derive a stable 36-hex device id from the account uid.
+*
+* The upstream keys desktop events to a device. Deriving it from the uid keeps
+* the same account looking like the same machine across runs, instead of a
+* new device appearing on every call.
+*/
+function deriveDeviceId(credential, salt) {
+	return createHash("sha256").update(salt + ":" + (credential.uid ?? "")).digest("hex").slice(0, 36);
+}
+/** Narrow a loose upstream value to an object, so field reads cannot throw. */
+function asRecord(value) {
+	return typeof value === "object" && value !== null ? value : {};
+}
+/** Read a numeric field, treating anything else as 0. */
+function numOf(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : 0;
+}
+/** Local `YYYY-MM-DD`, matching how the heatmap keys its cells. */
+function dayKeyLocal(date) {
+	const month = String(date.getMonth() + 1).padStart(2, "0");
+	const day = String(date.getDate()).padStart(2, "0");
+	return `${date.getFullYear()}-${month}-${day}`;
+}
 /** Billing request headers. */
 function billingHeaders(credential) {
 	const headers = {
@@ -190,6 +236,17 @@ function classifyUpstreamError(status, body) {
 	if (status >= 500) return "server";
 	return "client";
 }
+/**
+* Whether an error means "today is already checked in".
+*
+* Callers treat this as success: the credit for the day is already banked, so
+* reporting it as a failure would both alarm the user and hide a healthy
+* account behind a false negative.
+*/
+function isAlreadyCheckin(error) {
+	const message = error instanceof Error ? error.message : String(error);
+	return ALREADY_CHECKIN_MARKERS.some((marker) => message.includes(marker));
+}
 /** Parse the upstream's `credits` string into a multiplier. */
 function parseCreditMultiplier(value) {
 	if (typeof value !== "string") return void 0;
@@ -286,6 +343,199 @@ function parseUpstreamModel(value) {
 		...supportsImages === void 0 ? {} : { supportsImages }
 	};
 }
+/**
+* Flatten one upstream task entry.
+*
+* Progress is reported two ways depending on the task: flat `current`/`target`
+* fields, or a nested `progress: {current, target}`. The nested form wins when
+* it carries anything, because a task that reports both puts the live counter
+* there. Entries without a usable `task_code` are dropped — without one the
+* claim path cannot be built.
+*/
+/**
+* The event chain that scores the two Buddy-app tasks.
+*
+* Both tasks accept the same chain, and the chain is a pure value: building it
+* needs no client, so callers (and tests) can hold one without a live upstream.
+*
+* The task text says "upgrade to the desktop client and open it from the app
+* launcher". The scorer does not watch the UI — it watches this event sequence
+* with the desktop fingerprint, which is why the sequence is what gets sent.
+*
+* Measured against the live upstream: progress 0/1 → 1/1 claimable in ~8s.
+*/
+/**
+* A complete "desktop client ran a request successfully" event chain.
+*
+* Six events in the order the real client emits them: task created, message
+* send, request send, message response, message status, request response.
+* Several tasks are scored off this chain (or one that embeds it), because what
+* they measure is "a real request completed", which the client only proves
+* through this exact sequence.
+*
+* Measured: this chain alone lights up `RichMeow_Chat`.
+*/
+function desktopChatEvents(conversationId, requestId, messageId, modelId = "fast-model", modelName = "fast-model") {
+	const assistant = `${messageId}-assistant`;
+	const session = {
+		"codebuddy.session_id": conversationId,
+		"codebuddy.conversation_request_id": requestId
+	};
+	return [
+		{
+			eventCode: "agent_task_created",
+			source: "LOCAL",
+			name: "working",
+			task_target: "local",
+			mode: "craft",
+			requestModelId: modelId,
+			requestModelName: modelName,
+			has_repo: false,
+			repo_type: "none",
+			workspace_type: "empty",
+			has_connector: false,
+			connector_types: [],
+			has_mention: false,
+			mention_types: [],
+			has_template: false,
+			action: "",
+			template_name: "",
+			has_expert: false,
+			expert_id: "",
+			expert_name: "",
+			expert_industry_id: "",
+			has_skill: false,
+			skill_names: [],
+			conversationId,
+			messageId,
+			buddyId: "",
+			buddyName: ""
+		},
+		{
+			eventCode: "chat_message_send",
+			messageId: assistant,
+			historyCount: 0,
+			isContextTruncated: false,
+			currentStepCount: 1,
+			traceId: requestId,
+			rootRequestId: requestId,
+			parentConversationId: conversationId,
+			agentName: "cli",
+			agentType: "main"
+		},
+		{
+			eventCode: "chat_request_send",
+			inputLength: 24,
+			isPlan: false,
+			isAutoExecuteTerminal: false,
+			isAutoModify: false,
+			codebaseEnable: false,
+			maxToken: 0,
+			maxSteps: 500,
+			temperature: 0,
+			maxRetries: 0,
+			mentionContexts: [],
+			knowledgeId: [],
+			knowledgeName: [],
+			codebaseId: "",
+			mentionContextCount: 0,
+			command: "",
+			recommendId: "",
+			skillId: "",
+			skillCount: 0,
+			totalCount: 0,
+			traceId: requestId,
+			rootRequestId: requestId,
+			parentConversationId: conversationId,
+			agentName: "cli",
+			agentType: "main",
+			...session
+		},
+		{
+			eventCode: "chat_message_response",
+			messageId: assistant,
+			responseModelId: modelId,
+			inputToken: 120,
+			outputToken: 80,
+			totalToken: 200,
+			cachedTokens: 0,
+			cachedWriteTokens: 0,
+			cachedMissTokens: 0,
+			isSuccessful: true,
+			messageErrorCode: "",
+			finishReason: "stop",
+			firstTokenAt: Date.now(),
+			traceId: requestId,
+			conversationId,
+			rootRequestId: requestId,
+			parentConversationId: conversationId,
+			agentName: "cli",
+			agentType: "main",
+			...session
+		},
+		{
+			eventCode: "chat_message_status",
+			messageId: assistant,
+			messageErrorCode: "0",
+			traceId: requestId,
+			rootRequestId: requestId,
+			parentConversationId: conversationId,
+			agentName: "cli",
+			agentType: "main"
+		},
+		{
+			eventCode: "chat_request_response",
+			mode: "craft",
+			toolCallCount: 0,
+			inputToken: 120,
+			outputToken: 80,
+			totalToken: 200,
+			cachedTokens: 0,
+			cachedWriteTokens: 0,
+			cachedMissTokens: 0,
+			isSuccessful: true,
+			messageErrorCode: "",
+			finishReason: "stop",
+			rootRequestId: requestId,
+			parentConversationId: conversationId
+		}
+	];
+}
+function parseTask(value) {
+	if (typeof value !== "object" || value === null) return void 0;
+	const raw = value;
+	const taskCode = typeof raw["task_code"] === "string" ? raw["task_code"] : "";
+	if (taskCode === "") return void 0;
+	const num = (key) => typeof raw[key] === "number" ? raw[key] : 0;
+	let current = num("current");
+	let target = num("target");
+	const progress = raw["progress"];
+	if (typeof progress === "object" && progress !== null) {
+		const nested = progress;
+		const nestedCurrent = typeof nested["current"] === "number" ? nested["current"] : 0;
+		const nestedTarget = typeof nested["target"] === "number" ? nested["target"] : 0;
+		if (nestedTarget > 0 || nestedCurrent > 0) {
+			current = nestedCurrent;
+			target = nestedTarget;
+		}
+	}
+	const acceptStatus = typeof raw["accept_status"] === "string" ? raw["accept_status"] : "";
+	const claimed = acceptStatus === "claimed";
+	return {
+		taskCode,
+		title: typeof raw["title"] === "string" && raw["title"] !== "" ? raw["title"] : taskCode,
+		credit: num("reward_credit"),
+		energy: num("reward_energy"),
+		hasReward: raw["has_reward"] === true,
+		target,
+		current,
+		acceptStatus,
+		status: typeof raw["status"] === "string" ? raw["status"] : "",
+		claimable: !claimed && target > 0 && current >= target,
+		claimed,
+		locked: raw["locked"] === true
+	};
+}
 var WorkBuddyUpstreamClient = class {
 	fetchImpl;
 	clientVersion;
@@ -562,6 +812,531 @@ var WorkBuddyUpstreamClient = class {
 			isStreakDay: data["is_streak_day"] === true
 		};
 	}
+	/**
+	* Public fingerprint fields every desktop event carries.
+	*
+	* The upstream scores a desktop-fingerprinted task only when the event looks
+	* like it came from the desktop client: the same field set, the same stable
+	* device ids, the same build. A partial map is accepted with 200 and scores
+	* nothing, so these are copied wholesale rather than trimmed.
+	*
+	* `machineId`/`sessionId` are DERIVED from the account uid, never random: a
+	* new device id on every call is itself a signal that the traffic is not a
+	* real client.
+	*/
+	desktopFingerprint(credential) {
+		const now = Date.now();
+		return {
+			timezone: "Asia/Shanghai",
+			reportDelay: 2e3,
+			userId: credential.uid ?? "",
+			username: credential.nickname ?? "",
+			userNickname: credential.nickname ?? "",
+			product: "SaaS",
+			releaseDate: 1789036585355,
+			commit: "5f9692923c93033111c51ad7b003eb80204a9b75",
+			ideName: "WorkBuddy",
+			ideType: "WorkBuddy",
+			ideVersion: "5.5.6",
+			machineId: deriveDeviceId(credential, "machine"),
+			sessionId: deriveDeviceId(credential, "session"),
+			extName: "workbuddy-desktop",
+			extVersion: "5.5.6",
+			os: "win32",
+			arch: "x64",
+			osVersion: "10.0.26220",
+			cpuCores: 20,
+			memorySize: 24,
+			timestamp: now,
+			presentAt: now
+		};
+	}
+	/**
+	* Send desktop-fingerprinted events to the growth system.
+	*
+	* The body is an ARRAY of events, and every event carries the full desktop
+	* fingerprint plus its own business fields. Different tasks recognise
+	* different fingerprint families (CLI / desktop / web), which is why this is
+	* separate from {@link reportActivity}: they are not interchangeable.
+	*
+	* Business fields win over the fingerprint, so a caller can override a device
+	* id to align with a real install.
+	*/
+	async reportDesktopEvents(credential, events) {
+		if (events.length === 0) return;
+		const fingerprint = this.desktopFingerprint(credential);
+		const body = events.map((event) => ({
+			...fingerprint,
+			...event
+		}));
+		const response = await this.fetchImpl(`${chatBase(credential)}${DESKTOP_REPORT_PATH}`, {
+			method: "POST",
+			headers: {
+				"Authorization": `Bearer ${credential.accessToken}`,
+				"Accept": "application/json, text/plain, */*",
+				"Content-Type": "application/json;charset=UTF-8",
+				"User-Agent": DESKTOP_TASK_UA,
+				"X-Product": "SaaS",
+				"X-Request-ID": deriveDeviceId(credential, "req") + String(Date.now() % 1e6),
+				...credential.uid === void 0 || credential.uid === "" ? {} : { "X-User-Id": credential.uid },
+				...credential.domain === "" ? {} : { "X-Domain": credential.domain }
+			},
+			body: JSON.stringify(body),
+			signal: AbortSignal.timeout(JSON_TIMEOUT_MS)
+		});
+		const envelope = await readEnvelope(response);
+		if (!response.ok || envelope.code !== 0) throw envelopeError(response.status, envelope);
+	}
+	/**
+	* Report one chat-activity event to the growth system.
+	*
+	* The body is an ARRAY holding a single `chat_request_send` event, and every
+	* field is filled in: a three-field minimal event is accepted with 200 and
+	* then silently dropped, so the full shape is load-bearing rather than
+	* cosmetic. `userId` is the one field the server actually keys on — without
+	* it the request still answers 200 and scores nothing.
+	*
+	* One report per account per day is the quota the reference panel settled on;
+	* a single report lights the growth streak and unlocks the `first_buddy`
+	* family, which is why this runs before the task-centre pass.
+	
+	/**
+	* Send a WEB-fingerprinted event.
+	*
+	* A third fingerprint family, alongside CLI and desktop: a browser shape
+	* posted to the web origin with x-client-platform: web. Page-behaviour
+	* tasks such as `Library_read` are scored on it. Measured:
+	* `library_doc_intro_click` scored about four seconds after landing.
+	*/
+	async reportWebEvent(credential, eventCode, pageUrl, elementId, elementName) {
+		const ua = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/152.0.0.0 Safari/537.36";
+		const event = {
+			eventCode,
+			timestamp: Date.now(),
+			reportDelay: 0,
+			pageURL: pageUrl,
+			elementId,
+			elementName,
+			os: "Win32",
+			arch: "",
+			osVersion: "10.0",
+			userAgent: ua,
+			machineId: deriveDeviceId(credential, "webmachine"),
+			userId: credential.uid ?? "",
+			userNickname: credential.nickname ?? "",
+			enterpriseId: credential.enterpriseId ?? ""
+		};
+		const response = await this.fetchImpl(`https://www.workbuddy.cn/v2/report`, {
+			method: "POST",
+			headers: {
+				"Authorization": `Bearer ${credential.accessToken}`,
+				"Content-Type": "application/json",
+				"Accept": "application/json",
+				"x-client-platform": "web",
+				"Origin": "https://www.workbuddy.cn",
+				"Referer": pageUrl,
+				"User-Agent": ua,
+				...credential.uid === void 0 || credential.uid === "" ? {} : { "X-User-Id": credential.uid }
+			},
+			body: JSON.stringify([event]),
+			signal: AbortSignal.timeout(JSON_TIMEOUT_MS)
+		});
+		const envelope = await readEnvelope(response);
+		if (!response.ok || envelope.code !== 0) throw envelopeError(response.status, envelope);
+	}
+	/**
+	* Apply an appearance theme on the account.
+	*
+	* The theme task is scored on the `appearance_skin_apply` event, not on this
+	* call — but the event alone is not enough either. The pair is what a real
+	* client produces: it PATCHes the account's selected skin, then reports the
+	* event as the settings page closes. Measured on the reference panel after
+	* the earlier "the API alone does not score" reading was corrected.
+	*/
+	async setAppearanceTheme(credential, resourceKey) {
+		const response = await this.fetchImpl(`${chatBase(credential)}${APPEARANCE_SET_PATH}`, {
+			method: "POST",
+			headers: {
+				"Authorization": `Bearer ${credential.accessToken}`,
+				"Accept": "application/json, text/plain, */*",
+				"Content-Type": "application/json;charset=UTF-8",
+				"User-Agent": DESKTOP_TASK_UA,
+				"X-Product": "SaaS",
+				...credential.uid === void 0 || credential.uid === "" ? {} : { "X-User-Id": credential.uid }
+			},
+			body: JSON.stringify({
+				kind: "theme",
+				resource_key: resourceKey
+			}),
+			signal: AbortSignal.timeout(JSON_TIMEOUT_MS)
+		});
+		const envelope = await readEnvelope(response);
+		if (!response.ok || envelope.code !== 0) throw envelopeError(response.status, envelope);
+	}
+	/**
+	* The platform's expert marketplace.
+	*
+	* Needed before any expert can be summoned: the scorer verifies that the
+	* expert id exists on the platform, so a made-up id scores nothing. The
+	* response carries the display fields the summon events replay.
+	*/
+	async marketExpertList(credential, expertType = "") {
+		const request = {
+			page: 1,
+			page_size: 20,
+			sort_by: "reco_rank",
+			sort_order: "desc"
+		};
+		if (expertType !== "") request["expert_type"] = expertType;
+		const response = await this.fetchImpl(`${chatBase(credential)}${MARKET_EXPERT_LIST_PATH}`, {
+			method: "POST",
+			headers: {
+				...chatHeaders(credential),
+				"User-Agent": DESKTOP_TASK_UA
+			},
+			body: JSON.stringify(request),
+			signal: AbortSignal.timeout(JSON_TIMEOUT_MS)
+		});
+		const envelope = await readEnvelope(response);
+		if (!response.ok || envelope.code !== 0) throw envelopeError(response.status, envelope);
+		const data = asRecord(envelope.data);
+		const raw = Array.isArray(data["experts"]) ? data["experts"] : [];
+		const out = [];
+		for (const value of raw) {
+			const expert = asRecord(value);
+			const expertId = typeof expert["expert_id"] === "string" ? expert["expert_id"] : "";
+			if (expertId === "") continue;
+			out.push({
+				expertId,
+				expertType: typeof expert["expert_type"] === "string" ? expert["expert_type"] : "",
+				displayName: typeof expert["display_name_zh"] === "string" ? expert["display_name_zh"] : "",
+				profession: typeof expert["profession_zh"] === "string" ? expert["profession_zh"] : "",
+				version: typeof expert["version"] === "string" ? expert["version"] : "",
+				categories: Array.isArray(expert["categories"]) ? expert["categories"].filter((item) => typeof item === "string") : []
+			});
+		}
+		return out;
+	}
+	/**
+	* Open a REAL desktop conversation and return the ids the server assigned.
+	*
+	* The expert and skill tasks join their events to a conversation the server
+	* has actually seen, so a locally invented `requestId` scores nothing. This
+	* starts a chat, reads the server's id out of the SSE stream, then drops the
+	* rest of the stream — the answer itself is irrelevant, only its identity is.
+	*
+	* Returns `undefined` instead of throwing when the conversation cannot be
+	* opened or carries no recognisable id, because every caller is a best-effort
+	* task chain.
+	*/
+	async openConversation(credential, expertId = "", signal) {
+		const conversationId = `wb2auto-conv-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+		const body = JSON.stringify({
+			model: "fast-model",
+			messages: [{
+				role: "system",
+				content: "You are a helpful assistant. 当前处于中文环境，使用简体中文回答。"
+			}, {
+				role: "user",
+				content: "1+1等于几？直接回答。"
+			}],
+			agent: "cli",
+			temperature: 1,
+			stream: true,
+			stream_options: { include_usage: true }
+		});
+		let response;
+		try {
+			response = await this.fetchImpl(`${chatBase(credential)}/v2/chat/completions`, {
+				method: "POST",
+				headers: {
+					...chatHeaders(credential),
+					"Accept": "text/event-stream",
+					"User-Agent": DESKTOP_TASK_UA,
+					"X-Conversation-ID": conversationId,
+					"X-Request-ID": String(Date.now()) + "000000",
+					"X-Agent-Intent": "craft",
+					"X-Agent-Type": "main",
+					"X-IDE-Name": "WorkBuddy",
+					"X-IDE-Type": "WorkBuddy",
+					"X-IDE-Version": "5.5.6",
+					"x-codebuddy-request": "1",
+					...expertId === "" ? {} : { "X-Expert-Id": expertId }
+				},
+				body,
+				signal: signal ?? AbortSignal.timeout(CHAT_TIMEOUT_MS)
+			});
+		} catch {
+			return;
+		}
+		if (!response.ok || response.body === null) {
+			await response.body?.cancel().catch(() => {});
+			return;
+		}
+		const reader = response.body.getReader();
+		const decoder = new TextDecoder();
+		let buffer = "";
+		try {
+			while (buffer.length < SSE_SCAN_LIMIT) {
+				const chunk = await reader.read();
+				if (chunk.done) break;
+				buffer += decoder.decode(chunk.value, { stream: true });
+				const match = SERVER_ID_PATTERN.exec(buffer);
+				if (match !== null) return {
+					conversationId,
+					requestId: match[1] ?? ""
+				};
+			}
+		} catch {} finally {
+			await reader.cancel().catch(() => {});
+		}
+	}
+	/**
+	* Report one chat-activity event to the growth system.
+	*
+	* The body is an ARRAY holding a single chat_request_send event, and every
+	* field is filled in: a three-field minimal event is accepted with 200 and
+	* then silently dropped, so the full shape is load-bearing rather than
+	* cosmetic. userId is the one field the server actually keys on.
+	*
+	* One report per account per day is the quota the reference panel settled
+	* on; a single report lights the growth streak and unlocks the first_buddy
+	* family, which is why this runs before the task-centre pass.
+	*/
+	async reportActivity(credential, conversationId) {
+		const conversationID = conversationId ?? `wb2api-${Date.now()}`;
+		const requestID = conversationID;
+		const now = Date.now();
+		const event = {
+			eventCode: "chat_request_send",
+			timestamp: now,
+			reportDelay: 0,
+			mode: "craft",
+			conversationId: conversationID,
+			requestId: requestID,
+			inputLength: 12,
+			requestModelId: "deepseek-v4-flash",
+			requestModelName: "DeepSeek V4 Flash",
+			isPlan: false,
+			isAutoExecuteTerminal: false,
+			isAutoModify: false,
+			codebaseEnable: false,
+			maxToken: 0,
+			maxSteps: 0,
+			temperature: 0,
+			maxRetries: 0,
+			mentionContexts: [],
+			knowledgeId: [],
+			knowledgeName: [],
+			codebaseId: "",
+			mentionContextCount: 0,
+			command: "",
+			expertId: "",
+			recommendId: "",
+			skillId: "",
+			skillCount: 0,
+			totalCount: 0,
+			fileUri: "",
+			presentAt: now,
+			traceId: "",
+			rootRequestId: requestID,
+			parentConversationId: conversationID,
+			agentName: "default",
+			agentType: "conversation",
+			userId: credential.uid ?? ""
+		};
+		const response = await this.fetchImpl(`${billingBase(credential)}/v2/report`, {
+			method: "POST",
+			headers: billingHeaders(credential),
+			body: JSON.stringify([event]),
+			signal: AbortSignal.timeout(JSON_TIMEOUT_MS)
+		});
+		const envelope = await readEnvelope(response);
+		if (!response.ok || envelope.code !== 0) throw envelopeError(response.status, envelope);
+	}
+	/**
+	* Read back the growth streak in days.
+	*
+	* This is the read-only oracle for {@link reportActivity}: a report that
+	* returned 200 yet left the streak untouched was silently dropped (a missing
+	* `userId` is the usual cause), so callers verify instead of trusting the
+	* status code.
+	*
+	* Two shape traps, both measured against the live upstream:
+	*
+	* - The path carries NO `/v2` prefix, unlike its sibling task endpoints under
+	*   `/v2/activity/growth/*`. Asking for the `/v2` form does not 404; it
+	*   answers with a body that carries no `streak` object at all.
+	* - The counter is nested as `data.streak.days`, not `data.days`. Reading the
+	*   flat field yields a constant 0, which would make every successful report
+	*   look like a silent drop.
+	*
+	* Returns 0 only when the field is genuinely absent.
+	*/
+	async growthStreakDays(credential) {
+		const response = await this.fetchImpl(`${chatBase(credential)}/activity/growth/streak`, {
+			headers: billingHeaders(credential),
+			signal: AbortSignal.timeout(JSON_TIMEOUT_MS)
+		});
+		const envelope = await readEnvelope(response);
+		if (!response.ok || envelope.code !== 0) throw envelopeError(response.status, envelope);
+		const data = typeof envelope.data === "object" && envelope.data !== null ? envelope.data : {};
+		const streak = typeof data["streak"] === "object" && data["streak"] !== null ? data["streak"] : {};
+		return typeof streak["days"] === "number" ? streak["days"] : 0;
+	}
+	/**
+	* The full streak picture: days, tier unlock state, and what each tier pays.
+	*
+	* Read before redeeming, because the tier state is the only honest answer to
+	* "is there anything to claim": the redeem endpoint answers 403 for a locked
+	* tier, which is indistinguishable from a real failure once the response is
+	* just an error.
+	*/
+	async growthStreakFull(credential) {
+		const data = await this.growthJson(credential, "GET", "/activity/growth/streak");
+		const streak = asRecord(data["streak"]);
+		const redemption = asRecord(data["redemption_status"]);
+		const cards = asRecord(data["makeup_cards"]);
+		const tiers = [];
+		if (Array.isArray(redemption["tiers"])) for (const entry of redemption["tiers"]) {
+			const tier = asRecord(entry);
+			const name = typeof tier["tier"] === "string" ? tier["tier"] : "";
+			if (name === "") continue;
+			tiers.push({
+				tier: name,
+				days: numOf(tier["days"]),
+				credit: numOf(tier["credit"]),
+				energy: numOf(tier["energy"]),
+				cards: numOf(tier["cards"]),
+				chances: numOf(tier["chances"]),
+				status: String(redemption[`tier_${name}_status`] ?? "")
+			});
+		}
+		return {
+			days: numOf(streak["days"]),
+			monthTotalDays: numOf(streak["month_total_days"]),
+			nextTier: typeof streak["next_tier"] === "string" ? streak["next_tier"] : "",
+			nextTierRemaining: numOf(streak["next_tier_remaining"]),
+			makeupCards: numOf(cards["balance"]),
+			tiers
+		};
+	}
+	/**
+	* Redeem one unlocked streak tier.
+	*
+	* A locked tier answers 403 ("连续登录天数不足"); callers check the status from
+	* {@link growthStreakFull} first, so this only throws for genuine failures.
+	* The client token is the upstream's idempotency key — a fresh one per attempt
+	* keeps a retry from being read as a duplicate of the last one.
+	*/
+	async redeemStreakTier(credential, tier) {
+		await this.growthJson(credential, "POST", "/activity/growth/redeem", {
+			tier,
+			client_token: randomUUID()
+		});
+	}
+	/** How many lottery draws are available right now. */
+	async lotteryChances(credential) {
+		return numOf((await this.growthJson(credential, "GET", "/activity/growth/lottery/summary"))["chances"]);
+	}
+	/**
+	* Draw the lottery once.
+	*
+	* Returns the raw prize payload: its shape is set by the running campaign, so
+	* it is passed through rather than modelled.
+	*/
+	async lotteryDraw(credential) {
+		return this.growthJson(credential, "POST", "/activity/growth/lottery/draw", { client_token: randomUUID() });
+	}
+	/**
+	* The buddy profile, or undefined when the account has no buddy yet.
+	*
+	* `data.buddy` is null / absent / an empty object depending on how far the
+	* account got, and all three mean the same thing to a caller: adopt first.
+	*/
+	async buddyInfo(credential) {
+		const buddy = asRecord((await this.growthJson(credential, "GET", "/activity/growth/buddy/info"))["buddy"]);
+		if (Object.keys(buddy).length === 0) return void 0;
+		return {
+			instanceId: numOf(buddy["instance_id"]),
+			name: String(buddy["name"] ?? "")
+		};
+	}
+	/** Agree to the buddy terms. Idempotent upstream. */
+	async buddyAgree(credential) {
+		await this.growthJson(credential, "POST", "/activity/growth/buddy/agreement", { agree: true });
+	}
+	/**
+	* Adopt the first buddy.
+	*
+	* Gated upstream on having reported activity that day: without it the answer
+	* is 400 "first_buddy task not completed yet". Callers treat that as "not yet"
+	* rather than an error, which is why it is thrown as-is for them to classify.
+	*/
+	async buddyAdoptFirst(credential) {
+		await this.growthJson(credential, "POST", "/activity/growth/buddy/first", {});
+	}
+	/** Current travel state for the account's buddy. */
+	async buddyTravelStatus(credential) {
+		const data = await this.growthJson(credential, "GET", "/activity/growth/buddy/travel/status");
+		return {
+			state: typeof data["state"] === "string" ? data["state"] : "",
+			recordId: numOf(data["record_id"]),
+			dailyLimitReached: data["daily_limit_reached"] === true,
+			rewardCredit: numOf(data["reward_credit"])
+		};
+	}
+	/**
+	* Send the buddy travelling.
+	*
+	* The location is always 4 (古镇客栈): the four locations have identical
+	* reward and duration ranges, so there is nothing to optimise.
+	*/
+	async buddyTravelDepart(credential, locationId = 4) {
+		await this.growthJson(credential, "POST", "/activity/growth/buddy/travel/depart", { location_id: locationId });
+	}
+	/**
+	* Collect an arrived trip's reward.
+	*
+	* `recordId` is required and comes from the status read; the upstream rejects
+	* a claim without it.
+	*/
+	async buddyTravelClaim(credential, recordId) {
+		return numOf((await this.growthJson(credential, "POST", "/activity/growth/buddy/travel/claim", { record_id: recordId }))["reward_credit"]);
+	}
+	/** Whether yesterday is a gap in the activity heatmap. */
+	async heatmapYesterdayMissed(credential) {
+		const data = await this.growthJson(credential, "GET", "/activity/growth/heatmap");
+		if (!Array.isArray(data["cells"])) return false;
+		const key = dayKeyLocal(/* @__PURE__ */ new Date(Date.now() - 864e5));
+		for (const entry of data["cells"]) {
+			const cell = asRecord(entry);
+			if (cell["date"] === key) return numOf(cell["score"]) === 0;
+		}
+		return false;
+	}
+	/** Spend one makeup card on a date. Idempotent for an already-filled date. */
+	async useMakeupCard(credential, date) {
+		await this.growthJson(credential, "POST", "/activity/growth/makeup-cards/use", { date });
+	}
+	/**
+	* Call a growth-domain endpoint and return its unwrapped `data`.
+	*
+	* These endpoints live on the chat host with the billing header set, and
+	* carry the same envelope as everything else. Centralised here because every
+	* growth call needs the identical envelope check.
+	*/
+	async growthJson(credential, method, path, body) {
+		const response = await this.fetchImpl(`${chatBase(credential)}${path}`, {
+			method,
+			headers: billingHeaders(credential),
+			...body === void 0 ? {} : { body: JSON.stringify(body) },
+			signal: AbortSignal.timeout(JSON_TIMEOUT_MS)
+		});
+		const envelope = await readEnvelope(response);
+		if (!response.ok || envelope.code !== 0) throw envelopeError(response.status, envelope);
+		return asRecord(envelope.data);
+	}
 	/** Legacy thin wrapper kept for `status`/`doctor`: returns raw envelope data. */
 	async credits(credential) {
 		try {
@@ -576,6 +1351,87 @@ var WorkBuddyUpstreamClient = class {
 			};
 		}
 	}
+	/**
+	* Fetch the growth task list for one account.
+	*
+	* The upstream answers `data.tasks[]`, and `claimable` is derived locally —
+	* the upstream does not mark it. Only a task whose progress reached its
+	* target and that is not already claimed counts as eligible.
+	*/
+	async listTasks(credential) {
+		const response = await this.fetchImpl(`${chatBase(credential)}/v2/activity/growth/tasks`, {
+			headers: chatHeaders(credential),
+			signal: AbortSignal.timeout(JSON_TIMEOUT_MS)
+		});
+		const envelope = await readEnvelope(response);
+		if (!response.ok || envelope.code !== 0) throw envelopeError(response.status, envelope);
+		const data = typeof envelope.data === "object" && envelope.data !== null ? envelope.data : {};
+		const raw = Array.isArray(data["tasks"]) ? data["tasks"] : [];
+		const out = [];
+		for (const entry of raw) {
+			const parsed = parseTask(entry);
+			if (parsed !== void 0) out.push(parsed);
+		}
+		return out;
+	}
+	/**
+	* Accept (enrol in) tasks by code.
+	*
+	* Accepting is the "sign up" half: it produces no progress by itself, and the
+	* upstream answers success for an already-accepted task, so replaying this is
+	* safe. Progress is lit by real activity (a chat, an activity report).
+	*/
+	async acceptTasks(credential, taskCodes) {
+		if (taskCodes.length === 0) return;
+		const response = await this.fetchImpl(`${chatBase(credential)}/v2/activity/growth/tasks/accept`, {
+			method: "POST",
+			headers: chatHeaders(credential),
+			body: JSON.stringify({ task_codes: [...taskCodes] }),
+			signal: AbortSignal.timeout(JSON_TIMEOUT_MS)
+		});
+		const envelope = await readEnvelope(response);
+		if (!response.ok || envelope.code !== 0) throw envelopeError(response.status, envelope);
+	}
+	/**
+	* Claim one task's reward.
+	*
+	* Two details differ from list/accept and are load-bearing:
+	*
+	* - The task code rides the PATH, not the body.
+	* - It is served by the web origin, not the chat host, and only when the
+	*   request carries the growth-centre Origin/Referer plus
+	*   `x-client-platform: web`. The chat host's `/reward/claim` path does not
+	*   exist and answers 400 "task not completed".
+	*
+	* A repeat claim answers `already_claimed` with zero credit, which is treated
+	* as success so the caller can stay idempotent.
+	*/
+	async claimTaskReward(credential, taskCode) {
+		const headers = {
+			...billingHeaders(credential),
+			"Accept": "application/json, text/plain, */*",
+			"Origin": "https://www.workbuddy.cn",
+			"Referer": "https://www.workbuddy.cn/profile/growth-center",
+			"x-client-platform": "web",
+			"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36"
+		};
+		const response = await this.fetchImpl(`https://www.workbuddy.cn/activity/growth/tasks/${encodeURIComponent(taskCode)}/claim`, {
+			method: "POST",
+			headers,
+			signal: AbortSignal.timeout(JSON_TIMEOUT_MS)
+		});
+		const envelope = await readEnvelope(response);
+		if (!response.ok || envelope.code !== 0) throw envelopeError(response.status, envelope);
+		const data = typeof envelope.data === "object" && envelope.data !== null ? envelope.data : {};
+		if (data["already_claimed"] === true) return {
+			credit: 0,
+			energy: 0
+		};
+		return {
+			credit: typeof data["credit"] === "number" ? data["credit"] : 0,
+			energy: typeof data["energy"] === "number" ? data["energy"] : 0
+		};
+	}
 };
 //#endregion
 //#region src/accounts.ts
@@ -807,6 +1663,25 @@ var WorkBuddyAccountPool = class {
 	*/
 	disabledIds = /* @__PURE__ */ new Set();
 	/**
+	* Per-account credit floor, keyed by account id. 0 (or absent) means "spend
+	* it all".
+	*
+	* A reserved balance is protection, not a hard limit the upstream knows
+	* about: the pool simply stops picking that account once its last known
+	* balance is at or below the floor, so the user keeps a cushion instead of
+	* draining every account to zero.
+	*/
+	creditReserves = /* @__PURE__ */ new Map();
+	/**
+	* Last known credit balance per account, epoch ms aside.
+	*
+	* Refreshed in the background after a successful request, so a pick can
+	* consult it. An account with no reading is treated as usable: refusing to
+	* pick an account just because its balance has not been checked yet would
+	* strand a healthy pool, and the first 402 still cools it as before.
+	*/
+	creditBalances = /* @__PURE__ */ new Map();
+	/**
 	* Last time each account served a request, epoch ms. Drives the idle term
 	* of the priority-mode weighting below: an account that just served loses to
 	* one that has been idle, so a small pool stops hammering a single account.
@@ -837,6 +1712,7 @@ var WorkBuddyAccountPool = class {
 		if (options.exhaustCooldownMs !== void 0 && options.exhaustCooldownMs >= 1e3) this.exhaustCooldownMs = options.exhaustCooldownMs;
 		if (options.distribution !== void 0) this.distribution = options.distribution;
 		if (options.disabledAccountIds !== void 0) this.disabledIds = new Set(options.disabledAccountIds);
+		if (options.creditReserves !== void 0) this.setCreditReserves(options.creditReserves);
 	}
 	/** Rescan the auth directories and merge newly discovered accounts. */
 	async scan() {
@@ -890,6 +1766,11 @@ var WorkBuddyAccountPool = class {
 	available(now, modelId, region) {
 		return this.accounts.filter((account) => {
 			if (this.disabledIds.has(account.id)) return false;
+			const reserve = this.creditReserves.get(account.id);
+			if (reserve !== void 0 && reserve > 0) {
+				const balance = this.creditBalances.get(account.id);
+				if (balance !== void 0 && balance <= reserve) return false;
+			}
 			if (account.cooldownUntilMs > now) return false;
 			if (modelId !== void 0 && (account.modelCooldowns[modelId] ?? 0) > now) return false;
 			if (region !== void 0 && regionOf(account.credential.domain) !== region) return false;
@@ -999,6 +1880,57 @@ var WorkBuddyAccountPool = class {
 		this.lastUsedAt.set(accountId, Date.now());
 	}
 	/**
+	* Record an account latest known credit balance.
+	*
+	* Called after a request and by the card balance refresh, so the reserve
+	* check has something to compare against. A reading for an unknown account is
+	* dropped: `scan()` rebuilds the account list and a stale id would otherwise
+	* accumulate forever.
+	*/
+	noteCredits(accountId, balance) {
+		if (!Number.isFinite(balance)) return;
+		if (!this.accounts.some((account) => account.id === accountId)) return;
+		this.creditBalances.set(accountId, balance);
+	}
+	/** Last known balance for one account, or undefined when never read. */
+	creditsOf(accountId) {
+		return this.creditBalances.get(accountId);
+	}
+	/** The credit floor the user set for one account; 0 when unset. */
+	creditReserveOf(accountId) {
+		return this.creditReserves.get(accountId) ?? 0;
+	}
+	/**
+	* Replace every reserve. Called from settings on each apply, so the map
+	* mirrors the saved document exactly instead of accumulating old keys.
+	*/
+	setCreditReserves(reserves) {
+		const next = /* @__PURE__ */ new Map();
+		for (const [id, value] of Object.entries(reserves)) if (Number.isFinite(value) && value > 0) next.set(id, Math.floor(value));
+		this.creditReserves = next;
+	}
+	/** Every reserve currently in force, keyed by account id. */
+	creditReservesInOrder() {
+		const out = {};
+		for (const account of this.accounts) {
+			const reserve = this.creditReserves.get(account.id);
+			if (reserve !== void 0 && reserve > 0) out[account.id] = reserve;
+		}
+		return out;
+	}
+	/**
+	* Whether an account is held back only by its reserve.
+	*
+	* Separates "resting to protect credits" from every other reason an account
+	* is out of rotation, which is what the card shows the user.
+	*/
+	isReserved(accountId) {
+		const reserve = this.creditReserves.get(accountId);
+		if (reserve === void 0 || reserve <= 0) return false;
+		const balance = this.creditBalances.get(accountId);
+		return balance !== void 0 && balance <= reserve;
+	}
+	/**
 	* The account that served the most recent request, if any.
 	*
 	* Distinct from "who would serve the next one": this is a record of what
@@ -1285,10 +2217,1244 @@ function catalogFromUpstream(models) {
 	return models.map(toModelInfo);
 }
 //#endregion
-//#region src/status.ts
-/** Format the per-model credit multipliers. */
-function formatRates(status) {
-	const lines = ["Model credit multipliers:"];
+//#region src/task-events.ts
+/**
+* The app the buddy chain enters.
+*
+* One chain lights up two tasks: `Buddy_App` (open any app) and `Buddy_App_QQ`
+* (the QQ-specific one), because this is a QQ-hosted app. Measured 0/1 → 1/1 on
+* both from a single chain.
+*/
+const BUDDY_APP_ID = "cb_y5Dy46tPQGGWtueMxXbe";
+const BUDDY_APP_NAME = "企鹅教师助手";
+/** A stable-ish id for a synthetic conversation, unique per call. */
+function syntheticId(prefix) {
+	return `wb2auto-${prefix}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+}
+/**
+* A chat chain seeded with a placeholder conversation/request id.
+*
+* Several tasks do not verify that the conversation exists — they only check
+* that the events in the chain carry *a* well-formed id — so a synthetic pair is
+* enough. `RichMeow_Chat`, `create_canvas` and `automation_1` were all measured
+* lighting up from exactly this.
+*/
+function syntheticChatChain(prefix) {
+	const conversationId = syntheticId(prefix);
+	const requestId = syntheticId(`${prefix}-req`);
+	return {
+		conversationId,
+		requestId,
+		events: desktopChatEvents(conversationId, requestId, `msg-${prefix}`)
+	};
+}
+/**
+* The buddy-app chain (two tasks).
+*
+* Five clicks in the order a user would make them: discover the app, see it,
+* enter it, confirm the account link, skip the second binding step.
+*/
+function buddyAppChain() {
+	const base = {
+		mode: "LOCAL",
+		buddyId: BUDDY_APP_ID,
+		buddyName: BUDDY_APP_NAME
+	};
+	return {
+		transport: "desktop",
+		events: [
+			{
+				...base,
+				eventCode: "buddyapp_discover_click"
+			},
+			{
+				...base,
+				eventCode: "buddyapp_show",
+				elementId: BUDDY_APP_ID,
+				elementName: BUDDY_APP_NAME,
+				position: 2
+			},
+			{
+				...base,
+				eventCode: "buddyapp_enter_click",
+				elementId: BUDDY_APP_ID,
+				elementName: BUDDY_APP_NAME,
+				position: 2,
+				isFirstPage: "1"
+			},
+			{
+				...base,
+				eventCode: "buddyapp_auth_confirm_click",
+				elementId: BUDDY_APP_ID,
+				elementName: BUDDY_APP_NAME
+			},
+			{
+				...base,
+				eventCode: "buddyapp_bindaccount_skip_click",
+				elementId: BUDDY_APP_ID,
+				elementName: BUDDY_APP_NAME
+			}
+		]
+	};
+}
+/**
+* The design-canvas chain (`create_canvas`, +300 — the joint largest reward).
+*
+* The two canvas events ride the same metrics channel as everything else, so no
+* real canvas is ever created; the chat chain in front supplies the ids they
+* reference. Measured 1/1 on three accounts.
+*/
+function canvasChain() {
+	const { conversationId, requestId, events } = syntheticChatChain("canvas");
+	return {
+		transport: "desktop",
+		events: [
+			...events,
+			{
+				eventCode: "wbx_design_canvas_task_create",
+				conversationId,
+				requestId,
+				source: "summon_keyword",
+				cost: 12e3,
+				isSuccessful: true
+			},
+			{
+				eventCode: "wbx_design_canvas_open",
+				conversationId,
+				requestId,
+				id: `ardot-file-${requestId.slice(-8)}`,
+				source: "summon_keyword",
+				type: "page",
+				cost: 13e3,
+				isSuccessful: true
+			}
+		]
+	};
+}
+/**
+* The scheduled-task event (`automation_1`).
+*
+* One event is the whole chain — measured 1/1 on two accounts. The name is only
+* for the server's own records, so a generated one is fine.
+*/
+function automationChain() {
+	return {
+		transport: "desktop",
+		events: [{
+			eventCode: "automated_task_create_suc",
+			name: `定时任务-${Date.now().toString(36)}`,
+			source: "manually",
+			modelId: "fast-model",
+			modelIsThinking: true,
+			connectorCount: 0,
+			skills: "",
+			skillCount: 0,
+			scheduleType: "once",
+			mode: "LOCAL"
+		}]
+	};
+}
+/**
+* The plain chat chain (`RichMeow_Chat`, and the base of the template chain).
+*
+* Measured: this chain alone lights `RichMeow_Chat`.
+*/
+function chatChain() {
+	const { events } = syntheticChatChain("chat");
+	return {
+		transport: "desktop",
+		events
+	};
+}
+/**
+* The "same as this case" chain (`playbook_prompt`).
+*
+* The scorer watches `playbook_prompt_send` — sending the prompt that the
+* inspiration case pre-fills — not the card impression or the button click, so
+* the whole click path is replayed for realism but the send is what counts.
+*/
+function playbookChain(caseId = PLAYBOOK_CASE_ID, caseName = PLAYBOOK_CASE_NAME) {
+	const { conversationId, requestId, events } = syntheticChatChain("pb");
+	const payload = {
+		id: caseId,
+		name: caseName,
+		type: "document",
+		categoryId: "",
+		categoryName: ""
+	};
+	return {
+		transport: "desktop",
+		events: [
+			...events,
+			{
+				eventCode: "web_element_click",
+				pageName: "playbook_detail",
+				elementId: "playbook_ctaClick",
+				elementName: caseName,
+				source: "discover"
+			},
+			{
+				eventCode: "playbook_cta_click",
+				source: "discover",
+				position: 0,
+				...payload
+			},
+			{
+				eventCode: "playbook_prompt_send",
+				conversationId,
+				requestId,
+				...payload
+			}
+		]
+	};
+}
+/** The inspiration case the reference panel sends a prompt for. */
+const PLAYBOOK_CASE_ID = "pm-gtm-launch-plan";
+const PLAYBOOK_CASE_NAME = "新产品上市 GTM 发布计划一页纸";
+/**
+* The five templates the reference panel cycles through, as `[id, name]`.
+*
+* The upstream does not check that these templates exist — only that five
+* distinct `template_used` events arrive — so they are the reference set.
+*/
+const TEMPLATE_PRESETS = [
+	["1", "深度研究"],
+	["2", "周报生成"],
+	["3", "竞品分析"],
+	["4", "活动策划"],
+	["5", "代码评审"]
+];
+/**
+* One "created a task from a template" chain (`template_5`, +100 for five).
+*
+* Each group is a chat chain (which supplies the ids the template events join
+* on) plus `agent_task_created_with_template` and `template_used`. Measured:
+* five groups in one report scored 5/5.
+*/
+function templateChain(templateId, templateName) {
+	const { conversationId, requestId, events } = syntheticChatChain(`tpl${templateId}`);
+	return {
+		transport: "desktop",
+		events: [
+			...events,
+			{
+				eventCode: "agent_task_created_with_template",
+				mode: "working",
+				isCustomModel: false,
+				id: templateId,
+				name: templateName,
+				requestId
+			},
+			{
+				eventCode: "template_used",
+				template_id: templateId,
+				task_mode: "working"
+			}
+		]
+	};
+}
+/** Every template group, ready to send in order. */
+function templateChains() {
+	return TEMPLATE_PRESETS.map(([id, name]) => templateChain(id, name));
+}
+/**
+* The library-introduction click (`Library_read`).
+*
+* Scored on the WEB fingerprint — the same event posted with the desktop
+* fingerprint scores nothing — so this chain returns a web transport and the
+* scheduler routes it through `reportWebEvent`.
+*/
+function libraryReadChain() {
+	return {
+		transport: "web",
+		web: {
+			eventCode: "web_element_click",
+			pageUrl: LIBRARY_DOC_URL,
+			elementId: "library_doc_intro_click",
+			elementName: "WorkBuddy资料库介绍"
+		}
+	};
+}
+/** The document the library click is reported against. */
+const LIBRARY_DOC_URL = "https://www.workbuddy.cn/space/d/o0KWYeynteVv06UnAZqIFm";
+/** The theme key `Hp_Appearance` is scored on (和平精英激战金秋). */
+const APPEARANCE_THEME_KEY = "theme-tkmw7j";
+/** The skill `skill_1` is scored on. */
+const SKILL_ID = "skill_2097350077599879168";
+const SKILL_NAME = "润泽小馆·日报撰写";
+const SKILL_VERSION = "1.0.0";
+/** The 腾讯轻量云 expert `Expert_lighthouse` is scored on. */
+const LIGHTHOUSE_EXPERT_ID = "ex_2cvvUZQhDyeJ";
+/**
+* Rewrite the chain so the chatting half claims a tool call happened.
+*
+* A skills task is only credited when the response reports
+* `finishReason: 'tool_calls'` — that is, the model loaded the skill as a tool —
+* rather than a plain text answer.
+*/
+function markToolCall(events) {
+	return events.map((event) => event["eventCode"] === "chat_message_response" ? {
+		...event,
+		finishReason: "tool_calls"
+	} : event);
+}
+/**
+* Build the `skill_1` chain from a REAL conversation.
+*
+* Unlike the template and canvas chains, this one is verified against the
+* conversation it names, so the caller must first open a real chat and hand the
+* server-side ids in.
+*/
+function skillChain(conversationId, requestId) {
+	const messageId = `msg-${requestId.slice(-8)}`;
+	return {
+		transport: "desktop",
+		events: [...markToolCall(desktopChatEvents(conversationId, requestId, messageId)), {
+			eventCode: "skill_info",
+			id: SKILL_NAME,
+			skillId: SKILL_ID,
+			skillVersion: SKILL_VERSION,
+			toolStatus: "success",
+			fileCount: 56,
+			source: "workbuddy-desktop",
+			conversationId,
+			requestId,
+			messageId,
+			requestModelId: "fast-model",
+			requestModelName: "fast-model",
+			traceId: requestId
+		}]
+	};
+}
+/** The theme-apply event `Hp_Appearance` is scored on. */
+function appearanceChain(themeKey = APPEARANCE_THEME_KEY) {
+	return {
+		transport: "desktop",
+		events: [{
+			eventCode: "appearance_skin_apply",
+			action: "apply",
+			source: "settings_close",
+			id: themeKey,
+			vipLevel: 0,
+			series: "",
+			type: "unknown"
+		}]
+	};
+}
+/**
+* The three "summon an expert" events (`expert_summon_click` and friends).
+*
+* Paid before the conversation, in the order the app emits them.
+*/
+function expertSummonEvents(expert) {
+	const category = expert.categories[0] ?? "expert-all";
+	const version = expert.version === "" ? "1.0.0" : expert.version;
+	return [
+		{
+			eventCode: "web_element_click",
+			source: expert.expertId,
+			type: category,
+			version,
+			elementId: "expert_summon_click",
+			elementName: "立即召唤",
+			pageURL: "/C:/Program%20Files/WorkBuddy/resources/app.asar/renderer/index.html"
+		},
+		{
+			eventCode: "expert_summon_click",
+			id: expert.expertId,
+			name: expert.displayName,
+			expertTitle: expert.profession,
+			type: "expert-all",
+			position: 0,
+			expertType: expert.expertType,
+			version,
+			mode: "LOCAL"
+		},
+		{
+			eventCode: "expert_summoned",
+			id: expert.expertId,
+			name: expert.displayName,
+			expertTitle: expert.profession,
+			type: "expert-all"
+		}
+	];
+}
+/**
+* The "an expert really answered" event, which is what the expert tasks count.
+*
+* The `requestId` must be the SERVER's id for a real chat: a made-up one scores
+* nothing, because the scorer looks the conversation up.
+*/
+function expertActualUseEvent(expert, conversationId, requestId, mode = "craft") {
+	const category = expert.categories[0] ?? "expert-all";
+	const version = expert.version === "" ? "1.0.0" : expert.version;
+	return {
+		eventCode: "expert_actual_use",
+		id: expert.expertId,
+		name: expert.displayName,
+		expertTitle: expert.profession,
+		type: category,
+		expertType: expert.expertType,
+		source: "builtin",
+		version,
+		cost: 9e3,
+		characterCount: 14,
+		mode,
+		conversationId,
+		requestId,
+		messageId: `msg-${requestId.slice(-8)}`,
+		requestModelId: "fast-model",
+		requestModelName: "fast-model"
+	};
+}
+/**
+* The chat chain for an expert conversation.
+*
+* `agent_task_created` carries the expert fields the scorer reads to attribute
+* the conversation to that expert.
+*/
+function expertChatEvents(expert, conversationId, requestId) {
+	return desktopChatEvents(conversationId, requestId, `msg-${requestId.slice(-8)}`).map((event) => event["eventCode"] === "agent_task_created" ? {
+		...event,
+		has_expert: true,
+		expert_id: expert.expertId,
+		expert_name: expert.displayName,
+		expert_industry_id: ""
+	} : event);
+}
+/**
+* The fallback record for the 腾讯轻量云 expert, used when the marketplace
+* listing cannot be read. The id is the one the task is scored against.
+*/
+const LIGHTHOUSE_EXPERT = {
+	expertId: LIGHTHOUSE_EXPERT_ID,
+	expertType: "agent",
+	displayName: "腾讯轻量云专家",
+	profession: "腾讯轻量云专家",
+	version: "1.0.2",
+	categories: []
+};
+/**
+* Tasks with a chain in this module.
+*
+* Membership is the filter the pass uses before it tries to build one, so a
+* task with no chain costs no upstream call. It has to be kept in step with
+* `chainsFor`'s switch: a code listed here with no case would be read and then
+* silently skipped.
+*/
+const EVENT_CHAIN_BUILDERS = {
+	Buddy_App: true,
+	Buddy_App_QQ: true,
+	create_canvas: true,
+	automation_1: true,
+	RichMeow_Chat: true,
+	playbook_prompt: true,
+	template_5: true,
+	Hp_Appearance: true,
+	Library_read: true,
+	skill_1: true,
+	expert_5: true,
+	Expert_team_use_3: true,
+	Expert_lighthouse: true
+};
+const AUTOMATION_TICK_MS = 6e4;
+const JOB_KINDS = [
+	"checkin",
+	"report",
+	"tasks",
+	"streak",
+	"travel"
+];
+const EMPTY_JOB_STATE = {
+	ok: 0,
+	failed: 0,
+	credit: 0,
+	energy: 0,
+	claimed: 0
+};
+/** `YYYY-MM-DD` in local time, the day key every job resets on. */
+/**
+* What the ledger gained between two snapshots, per account and in total.
+*
+* A diff rather than an absolute read: the card asks "what did this run do",
+* and the ledger holds the whole day, so reporting totals would re-count
+* everything an earlier run had already claimed.
+*/
+function diffEarnings(before, after) {
+	const accounts = {};
+	let credit = 0;
+	let energy = 0;
+	let claimed = 0;
+	for (const [id, entry] of Object.entries(after)) {
+		const was = before[id];
+		const gain = {
+			credit: entry.credit - (was?.credit ?? 0),
+			energy: entry.energy - (was?.energy ?? 0),
+			claimed: entry.claimed - (was?.claimed ?? 0),
+			checkinCredit: entry.checkinCredit - (was?.checkinCredit ?? 0),
+			bonusCredit: entry.bonusCredit - (was?.bonusCredit ?? 0),
+			travelCredit: entry.travelCredit - (was?.travelCredit ?? 0)
+		};
+		if (gain.credit === 0 && gain.energy === 0 && gain.claimed === 0 && gain.checkinCredit === 0 && gain.bonusCredit === 0 && gain.travelCredit === 0) continue;
+		accounts[id] = gain;
+		credit += gain.credit;
+		energy += gain.energy;
+		claimed += gain.claimed;
+	}
+	return {
+		credit,
+		energy,
+		claimed,
+		accounts
+	};
+}
+function dayKey(date) {
+	const month = String(date.getMonth() + 1).padStart(2, "0");
+	const day = String(date.getDate()).padStart(2, "0");
+	return `${date.getFullYear()}-${month}-${day}`;
+}
+/**
+* Whether `now`'s local hour is one of `hours`.
+*
+* The reference panel computes a `nextFire` instant and sleeps until it; this
+* loop instead wakes every minute and asks "is any job due now". Both fire at
+* the top of a configured hour, but the polling form cannot miss a slot to a
+* suspended process — a laptop that slept through 10:00 still runs the job the
+* moment it wakes, on the same day.
+*/
+function isFireHour(now, hours) {
+	return hours.includes(now.getHours());
+}
+/** Whether this account may be used: not switched off, not cooling. */
+function eligible(account, now) {
+	if (account.cooldownUntilMs > now) return false;
+	if (regionOf(account.credential.domain) === "global") return false;
+	return true;
+}
+const sleep = (ms) => new Promise((resolve) => {
+	setTimeout(resolve, ms);
+});
+/**
+* The points automation.
+*
+* Owns a single timer loop. Construction is inert — nothing runs until
+* {@link start}, and {@link stop} is idempotent so a plugin teardown that fires
+* twice is harmless.
+*/
+var WorkBuddyScheduler = class {
+	pool;
+	client;
+	logger;
+	now;
+	delayMs;
+	/**
+	* How long to wait for event scoring before re-reading the task list.
+	* Tests set 0 so a pass does not spend nine real seconds per account.
+	*/
+	eventScoreWaitMs;
+	/**
+	* Gap between two expert summon chains.
+	* Tests set 0 so a pass does not spend six real seconds per expert.
+	*/
+	expertGapMs;
+	enabled;
+	checkinHours;
+	taskHours;
+	reportHours;
+	streakHours;
+	travelHours;
+	timer;
+	running = false;
+	/** Guards against a slow run overlapping the next tick. */
+	busy = false;
+	/** True while a manual run is in flight, so the card can poll it. */
+	runInFlight = false;
+	/**
+	* Set once {@link stop} is called.
+	*
+	* Deliberately false before `start`: the loop is not running yet, but a
+	* manual `tick` must still work. `stop` is what makes a run abandon the
+	* accounts it has not reached yet.
+	*/
+	stopped = false;
+	states = {
+		checkin: { ...EMPTY_JOB_STATE },
+		report: { ...EMPTY_JOB_STATE },
+		tasks: { ...EMPTY_JOB_STATE },
+		streak: { ...EMPTY_JOB_STATE },
+		travel: { ...EMPTY_JOB_STATE }
+	};
+	claimableSeen = 0;
+	/**
+	* Credits/energy/tasks earned per account TODAY, keyed by account id.
+	*
+	* Cleared whenever the day key rolls over, so the card always answers
+	* "what did the automation get for THIS account today".
+	*/
+	earnings = /* @__PURE__ */ new Map();
+	/** Day key the counters above belong to. */
+	earningsDate = "";
+	/** Host hooks that persist the ledger across restarts. */
+	loadEarnings;
+	saveEarningsFn;
+	constructor(pool, client, options = {}) {
+		this.pool = pool;
+		this.client = client;
+		this.logger = options.logger ?? {};
+		this.now = options.now ?? (() => /* @__PURE__ */ new Date());
+		this.delayMs = options.accountDelayMs ?? 800;
+		this.eventScoreWaitMs = options.eventScoreWaitMs ?? 9e3;
+		this.expertGapMs = options.expertGapMs ?? 6e3;
+		this.loadEarnings = options.loadEarnings;
+		this.saveEarningsFn = options.saveEarnings;
+		const restored = options.loadEarnings?.();
+		const today = dayKey(this.now());
+		if (restored !== void 0 && restored.date === today) {
+			for (const [id, entry] of Object.entries(restored.accounts)) this.earnings.set(id, entry);
+			this.earningsDate = today;
+		}
+		this.enabled = options.enabled ?? false;
+		this.checkinHours = options.checkinHours ?? [9];
+		this.reportHours = options.reportHours ?? [10];
+		this.taskHours = options.taskHours ?? [11];
+		this.streakHours = options.streakHours ?? [12];
+		this.travelHours = options.travelHours ?? [12];
+	}
+	/** Apply a new configuration; safe to call while running. */
+	/**
+	* Install the persistence hook once the host settings service is available.
+	*
+	* Separate from the constructor because the scheduler is built with the pool,
+	* long before the settings section exists; a ledger written before that point
+	* would have nowhere to go.
+	*/
+	setEarningsPersistence(save) {
+		this.saveEarningsFn = save;
+	}
+	/**
+	* Fold a previously persisted ledger back in, when it belongs to today.
+	*
+	* Used after the settings document becomes readable, which happens after
+	* construction; a ledger from an earlier day is ignored so the counters never
+	* claim yesterday as today.
+	*/
+	applyEarningsLedger(ledger) {
+		const today = dayKey(this.now());
+		if (ledger.date !== today) return;
+		for (const [id, entry] of Object.entries(ledger.accounts)) this.earnings.set(id, entry);
+		this.earningsDate = today;
+	}
+	applyConfig(options) {
+		if (options.enabled !== void 0) this.enabled = options.enabled;
+		if (options.checkinHours !== void 0) this.checkinHours = options.checkinHours;
+		if (options.reportHours !== void 0) this.reportHours = options.reportHours;
+		if (options.taskHours !== void 0) this.taskHours = options.taskHours;
+		if (options.streakHours !== void 0) this.streakHours = options.streakHours;
+		if (options.travelHours !== void 0) this.travelHours = options.travelHours;
+	}
+	/** Hours for one job, used by the loop and the status document. */
+	hoursOf(kind) {
+		switch (kind) {
+			case "checkin": return this.checkinHours;
+			case "report": return this.reportHours;
+			case "tasks": return this.taskHours;
+			case "streak": return this.streakHours;
+			case "travel": return this.travelHours;
+		}
+	}
+	/** Start the loop. Idempotent. */
+	start() {
+		if (this.timer !== void 0) return;
+		this.stopped = false;
+		this.running = true;
+		this.timer = setInterval(() => {
+			this.tick();
+		}, AUTOMATION_TICK_MS);
+		this.timer.unref?.();
+	}
+	/** Stop the loop. Idempotent, and safe before `start`. */
+	stop() {
+		this.stopped = true;
+		this.running = false;
+		if (this.timer !== void 0) {
+			clearInterval(this.timer);
+			this.timer = void 0;
+		}
+	}
+	/** Snapshot for the status document. */
+	/**
+	* Run one job immediately, regardless of the clock.
+	*
+	* Exists so the automation can be verified from the card without waiting for
+	* its hour. A manual run is recorded exactly like a scheduled one, so the
+	* timer will not repeat it later the same day: every job is idempotent, but a
+	* second pass would still be wasted upstream calls.
+	*
+	* `force` ignores the already-ran-today guard, which is what pressing the
+	* button a second time means.
+	*/
+	async runNow(kind, force = false) {
+		const today = dayKey(this.now());
+		const state = this.states[kind];
+		if (!force && state.lastRunDate === today) return { ...state };
+		this.busy = true;
+		try {
+			await this.runJob(kind, today);
+		} finally {
+			this.busy = false;
+		}
+		return { ...this.states[kind] };
+	}
+	/**
+	* Run every job once, in the scheduled order.
+	*
+	* Order matters and is not configurable: the activity report has to land
+	* before the task pass reads task progress, or the pass sees counters the
+	* report would have moved. This is what the card's single button calls.
+	*/
+	/**
+	* Start a full pass in the background and return immediately.
+	*
+	* A pass takes tens of seconds - one upstream round trip per account per job,
+	* plus the scoring wait - which is far too long to hold the card request open:
+	* the browser or the host web server would time out, and the user would see
+	* a hung button for a run that is actually working.
+	*
+	* Returns whether a run started. A second call while one is in flight is
+	* ignored rather than queued: pressing the button twice means hurry up, and
+	* the run already under way covers it.
+	*/
+	startRunAll() {
+		if (this.runInFlight) return false;
+		this.runInFlight = true;
+		this.runAll().catch((error) => {
+			this.logger.warn?.("dsh-workbuddy-xdpool automation run failed:", error);
+		}).finally(() => {
+			this.runInFlight = false;
+		});
+		return true;
+	}
+	async runAll() {
+		const today = dayKey(this.now());
+		const before = this.earningsSnapshot();
+		let okCount = 0;
+		let failed = 0;
+		let jobsRun = 0;
+		for (const kind of JOB_KINDS) {
+			jobsRun += 1;
+			this.busy = true;
+			try {
+				await this.runJob(kind, today);
+			} finally {
+				this.busy = false;
+			}
+			okCount += this.states[kind].ok;
+			failed += this.states[kind].failed;
+		}
+		const gained = diffEarnings(before, this.earningsSnapshot());
+		return {
+			jobsRun,
+			okCount,
+			failed,
+			credit: gained.credit,
+			energy: gained.energy,
+			claimed: gained.claimed,
+			accounts: gained.accounts
+		};
+	}
+	status() {
+		const jobs = {};
+		for (const kind of JOB_KINDS) jobs[kind] = { ...this.states[kind] };
+		return {
+			enabled: this.enabled,
+			running: this.running,
+			checkinHours: this.checkinHours,
+			taskHours: this.taskHours,
+			reportHours: this.reportHours,
+			streakHours: this.streakHours,
+			travelHours: this.travelHours,
+			jobs,
+			claimableSeen: this.claimableSeen,
+			earningsToday: this.earningsSnapshot(),
+			runInProgress: this.runInFlight
+		};
+	}
+	/**
+	* One poll: run every due job, serially.
+	*
+	* Serial by design — the jobs share the same accounts and the upstream
+	* rate-limits per account, so overlapping passes would only trip that limit.
+	* A job that throws is recorded and the loop continues.
+	*/
+	async tick() {
+		if (!this.enabled || this.stopped || this.busy) return;
+		this.busy = true;
+		try {
+			const now = this.now();
+			const today = dayKey(now);
+			for (const kind of JOB_KINDS) {
+				if (this.stopped) return;
+				if (this.states[kind].lastRunDate === today) continue;
+				if (!isFireHour(now, this.hoursOf(kind))) continue;
+				await this.runJob(kind, today);
+			}
+		} catch (error) {
+			this.logger.warn?.("dsh-workbuddy-xdpool automation tick failed:", error);
+		} finally {
+			this.busy = false;
+		}
+	}
+	/** Run one job against every eligible account and record the outcome. */
+	/**
+	* Add one account's take to today's counters, resetting first if the day
+	* rolled over. Called from the task pass, which is the only job that earns.
+	*/
+	/**
+	* Today's per-account earnings, as a plain object for the status document.
+	*
+	* Rolls the day first so a status read just after midnight does not report
+	* yesterday's totals under today's date.
+	*/
+	earningsSnapshot() {
+		this.rollEarnings(dayKey(this.now()));
+		const out = {};
+		for (const [id, entry] of this.earnings) out[id] = { ...entry };
+		return out;
+	}
+	/**
+	* Add one account take to today counters, resetting first if the day rolled
+	* over. Every source is tracked separately so the card can show what earned
+	* what, rather than one opaque total.
+	*/
+	recordEarnings(accountId, today, delta) {
+		this.rollEarnings(today);
+		const credit = delta.credit ?? 0;
+		const energy = delta.energy ?? 0;
+		const claimed = delta.claimed ?? 0;
+		const checkinCredit = delta.checkinCredit ?? 0;
+		const bonusCredit = delta.bonusCredit ?? 0;
+		const travelCredit = delta.travelCredit ?? 0;
+		if (credit === 0 && energy === 0 && claimed === 0 && checkinCredit === 0 && bonusCredit === 0 && travelCredit === 0) return;
+		const existing = this.earnings.get(accountId);
+		this.earnings.set(accountId, {
+			credit: (existing?.credit ?? 0) + credit,
+			energy: (existing?.energy ?? 0) + energy,
+			claimed: (existing?.claimed ?? 0) + claimed,
+			checkinCredit: (existing?.checkinCredit ?? 0) + checkinCredit,
+			bonusCredit: (existing?.bonusCredit ?? 0) + bonusCredit,
+			travelCredit: (existing?.travelCredit ?? 0) + travelCredit,
+			date: today
+		});
+		this.persistEarnings();
+	}
+	/** Clear the per-account counters when the local day changes. */
+	rollEarnings(today) {
+		if (this.earningsDate === today) return;
+		this.earningsDate = today;
+		this.earnings.clear();
+		this.claimableSeen = 0;
+		this.persistEarnings();
+	}
+	/**
+	* Write the ledger through the host hook, when one was supplied.
+	*
+	* Best effort on purpose: a failed save must never abort a run that has
+	* already collected rewards, and the in-memory ledger keeps serving the card
+	* for the rest of the session either way.
+	*/
+	persistEarnings() {
+		if (this.saveEarningsFn === void 0) return;
+		try {
+			const accounts = {};
+			for (const [id, entry] of this.earnings) accounts[id] = entry;
+			this.saveEarningsFn({
+				date: this.earningsDate,
+				accounts
+			});
+		} catch (error) {
+			this.logger.warn?.("dsh-workbuddy-xdpool: could not persist automation earnings:", error);
+		}
+	}
+	/**
+	* Run one job against every eligible account and record the outcome.
+	*
+	* The task job runs in TWO passes. The first sends the event chains that light
+	* up client-scored tasks; the second collects rewards. They are separate
+	* because scoring lands asynchronously — a chain sent and claimed within the
+	* same breath finds the task still un-scored — and because sending is fast
+	* while claiming wants the whole pool to have been lit up first. Splitting
+	* them costs one shared wait instead of one wait per account.
+	*/
+	async runJob(kind, today) {
+		const accountWord = kind === "report" ? "report" : kind;
+		let ok = 0;
+		let failed = 0;
+		let credit = 0;
+		let energy = 0;
+		let claimed = 0;
+		const accounts = this.accountsInOrder();
+		if (kind === "tasks") await this.sendEventChains(accounts);
+		for (let index = 0; index < accounts.length; index++) {
+			if (this.stopped) break;
+			const account = accounts[index];
+			if (account === void 0) continue;
+			try {
+				switch (kind) {
+					case "checkin":
+						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`);
+						} catch (error) {
+							if (!isAlreadyCheckin(error)) throw error;
+							this.logger.info?.(`automation checkin ${account.label}: already done today`);
+						}
+						break;
+					case "report": {
+						const days = await this.reportOne(account);
+						this.logger.info?.(`automation report ${account.label}: streak days=${days}`);
+						break;
+					}
+					case "tasks": {
+						const result = await this.runTasks(account);
+						credit += result.credit;
+						energy += result.energy;
+						claimed += result.claimed;
+						this.claimableSeen += result.claimableCount;
+						this.recordEarnings(account.id, today, {
+							credit: result.credit,
+							energy: result.energy,
+							claimed: result.claimed
+						});
+						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);
+						break;
+					case "travel": await this.runTravel(account);
+				}
+				ok++;
+			} catch (error) {
+				failed++;
+				this.logger.warn?.(`automation ${accountWord} ${account.label} failed:`, error);
+			}
+			if (index < accounts.length - 1 && this.delayMs > 0 && !this.stopped) await sleep(this.delayMs);
+		}
+		const state = this.states[kind];
+		state.lastRunDate = today;
+		state.lastRunAtMs = this.now().getTime();
+		state.ok = ok;
+		state.failed = failed;
+		state.credit = credit;
+		state.energy = energy;
+		state.claimed = claimed;
+		state.message = this.summarise(kind, ok, failed, claimed, credit, energy);
+		this.logger.info?.(`automation ${accountWord}: ${state.message}`);
+	}
+	/** Compose the one-line summary shown on the card. */
+	summarise(kind, ok, failed, claimed, credit, energy) {
+		if (kind === "tasks") return `${ok} accounts, ${claimed} tasks claimed (+${credit} credit, +${energy} energy)${failed > 0 ? `, ${failed} failed` : ""}`;
+		return `${ok} accounts ok${failed > 0 ? `, ${failed} failed` : ""}`;
+	}
+	/**
+	* Accounts to run against, in pool order.
+	*
+	* Disabled accounts are excluded here rather than filtered by the caller so a
+	* card switch takes effect on the next pass without any event plumbing.
+	*/
+	accountsInOrder() {
+		const now = Date.now();
+		return this.pool.list().filter((account) => {
+			if (this.pool.isDisabled(account.id)) return false;
+			return eligible(account, now);
+		});
+	}
+	/**
+	* Send one activity report, then verify it landed.
+	*
+	* The upstream answers 200 even when it drops the event, so the streak is
+	* read back as the oracle: `days > 0` means it counted. A failed read-back is
+	* logged and treated as a suspicious result, never as a retry — the report is
+	* idempotent per day, and hammering it is exactly what the one-a-day quota
+	* exists to avoid.
+	*/
+	async reportOne(account) {
+		await this.client.reportActivity(account.credential);
+		try {
+			const days = await this.client.growthStreakDays(account.credential);
+			if (days === 0) this.logger.warn?.(`automation report ${account.label}: streak days=0 right after report (new account or scoring lag?)`);
+			return days;
+		} catch (error) {
+			this.logger.warn?.(`automation report ${account.label}: streak read-back failed:`, error);
+			return -1;
+		}
+	}
+	async sendEventChains(accounts) {
+		let sentAnything = false;
+		for (const account of accounts) {
+			if (this.stopped) return;
+			let tasks;
+			try {
+				tasks = await this.client.listTasks(account.credential);
+			} catch (error) {
+				this.logger.warn?.(`automation events ${account.label}: list failed:`, error);
+				continue;
+			}
+			const pending = tasks.filter((task) => task.taskCode in EVENT_CHAIN_BUILDERS && !task.claimable && !task.locked);
+			for (const task of pending) {
+				if (this.stopped) return;
+				let chains;
+				try {
+					chains = await this.chainsFor(task, account.credential);
+				} catch (error) {
+					this.logger.warn?.(`automation events ${account.label}: ${task.taskCode} could not be built:`, error);
+					continue;
+				}
+				for (const chain of chains) {
+					if (this.stopped) return;
+					try {
+						await this.sendChain(account.credential, chain);
+						this.logger.info?.(`automation events ${account.label}: ${task.taskCode} chain sent`);
+						sentAnything = true;
+					} catch (error) {
+						this.logger.warn?.(`automation events ${account.label}: ${task.taskCode} failed:`, error);
+						break;
+					}
+					if (this.delayMs > 0 && !this.stopped) await sleep(this.delayMs);
+				}
+			}
+		}
+		if (sentAnything && this.eventScoreWaitMs > 0 && !this.stopped) await sleep(this.eventScoreWaitMs);
+	}
+	/**
+	* Send one chain on the channel it was built for.
+	*
+	* The transport is not a detail of the sender: the scorer keys different
+	* tasks to different fingerprint families, so a web-scored event posted as a
+	* desktop event is accepted and then ignored.
+	*/
+	async sendChain(credential, chain) {
+		if (chain.transport === "web") {
+			const web = chain.web;
+			if (web === void 0) throw new Error("web chain without a web event");
+			await this.client.reportWebEvent(credential, web.eventCode, web.pageUrl, web.elementId, web.elementName);
+			return;
+		}
+		await this.client.reportDesktopEvents(credential, chain.events ?? []);
+	}
+	/**
+	* Build every chain that scores one task.
+	*
+	* Most tasks need a single chain; `template_5` needs five, because the scorer
+	* counts distinct `template_used` events rather than a boolean. The two tasks
+	* that join a conversation (skill, expert) open a real one first, which is why
+	* this is async.
+	*/
+	async chainsFor(task, credential) {
+		switch (task.taskCode) {
+			case "Buddy_App":
+			case "Buddy_App_QQ": return [buddyAppChain()];
+			case "create_canvas": return [canvasChain()];
+			case "automation_1": return [automationChain()];
+			case "RichMeow_Chat": return [chatChain()];
+			case "playbook_prompt": return [playbookChain()];
+			case "template_5": return templateChains();
+			case "Hp_Appearance":
+				await this.client.setAppearanceTheme(credential, APPEARANCE_THEME_KEY);
+				if (this.delayMs > 0 && !this.stopped) await sleep(2e3);
+				return [appearanceChain()];
+			case "Library_read": return [libraryReadChain()];
+			case "skill_1": {
+				const chat = await this.client.openConversation(credential);
+				if (chat === void 0) throw new Error("skill_1: no server conversation");
+				return [skillChain(chat.conversationId, chat.requestId)];
+			}
+			case "expert_5": return this.expertChains(credential, "agent", task);
+			case "Expert_team_use_3": return this.expertChains(credential, "team", task);
+			case "Expert_lighthouse": return this.lighthouseChains(credential);
+			default: return [];
+		}
+	}
+	/**
+	* The summon-and-use chains for the expert tasks.
+	*
+	* Two steps per expert, and both are load-bearing: the summon events alone are
+	* impressions, and a use event on its own scores nothing because the scorer
+	* looks the conversation up. Only a real chat with `X-Expert-Id` produces an
+	* id it will accept.
+	*/
+	async expertChains(credential, expertType, task) {
+		const needed = Math.max(0, task.target - task.current);
+		if (needed === 0) return [];
+		const experts = await this.client.marketExpertList(credential, expertType);
+		const out = [];
+		for (const expert of experts) {
+			if (out.length >= needed) break;
+			if (this.stopped) break;
+			try {
+				await this.client.reportDesktopEvents(credential, expertSummonEvents(expert));
+				if (this.delayMs > 0 && !this.stopped) await sleep(this.delayMs);
+				const chat = await this.client.openConversation(credential, expert.expertId);
+				if (chat === void 0) continue;
+				out.push({
+					transport: "desktop",
+					events: [...expertChatEvents(expert, chat.conversationId, chat.requestId), expertActualUseEvent(expert, chat.conversationId, chat.requestId)]
+				});
+			} catch (error) {
+				this.logger.warn?.(`automation events expert ${expert.expertId}:`, error);
+			}
+			if (this.expertGapMs > 0 && !this.stopped) await sleep(this.expertGapMs);
+		}
+		return out;
+	}
+	/**
+	* The 腾讯轻量云 expert chain.
+	*
+	* Structurally the same as the expert task, with two differences the scorer
+	* checks: `agent_task_created` has to name the expert, and the use event has
+	* to report `mode: 'LOCAL'` with an empty type and zero cost — that is what
+	* the lighthouse criterion looks for.
+	*/
+	async lighthouseChains(credential) {
+		let expert = LIGHTHOUSE_EXPERT;
+		try {
+			const found = (await this.client.marketExpertList(credential, "agent")).find((item) => item.expertId === LIGHTHOUSE_EXPERT_ID);
+			if (found !== void 0) expert = found;
+		} catch (error) {
+			this.logger.warn?.("automation events lighthouse list:", error);
+		}
+		await this.client.reportDesktopEvents(credential, expertSummonEvents(expert));
+		if (this.delayMs > 0 && !this.stopped) await sleep(this.delayMs);
+		const chat = await this.client.openConversation(credential, expert.expertId);
+		if (chat === void 0) throw new Error("Expert_lighthouse: no server conversation");
+		const use = expertActualUseEvent(expert, chat.conversationId, chat.requestId, "LOCAL");
+		use["type"] = "";
+		use["cost"] = 0;
+		return [{
+			transport: "desktop",
+			events: [...expertChatEvents(expert, chat.conversationId, chat.requestId), use]
+		}];
+	}
+	/**
+	* The task-centre pass for one account.
+	*
+	* Order matters: enrich first (enrol in everything open), then claim. Both
+	* halves are idempotent — accepting an already-accepted task succeeds, and a
+	* repeat claim answers `already_claimed` — so a pass that dies halfway is
+	* safe to replay on the next tick.
+	*/
+	async runTasks(account) {
+		const credential = account.credential;
+		const open = (await this.client.listTasks(credential)).filter((task) => task.acceptStatus === "not_accepted" && !task.locked).map((task) => task.taskCode);
+		if (open.length > 0) await this.client.acceptTasks(credential, open);
+		const claimable = (await this.client.listTasks(credential)).filter((task) => task.claimable && !task.locked);
+		let credit = 0;
+		let energy = 0;
+		let claimed = 0;
+		for (const task of claimable) {
+			if (this.stopped) break;
+			const reward = await this.client.claimTaskReward(credential, task.taskCode);
+			credit += reward.credit;
+			energy += reward.energy;
+			if (reward.credit > 0 || reward.energy > 0) {
+				claimed++;
+				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);
+		}
+		return {
+			claimed,
+			credit,
+			energy,
+			claimableCount: claimable.length
+		};
+	}
+	/**
+	* Streak redemption plus the lottery it unlocks.
+	*
+	* Tiers unlock on consecutive active days (7/14/28). Redeeming one pays
+	* credits, energy, a makeup card and — the part nothing else grants — lottery
+	* draws, so the draw runs straight after and only for the chances in hand.
+	*
+	* Everything here is idempotent: a tier already claimed is skipped by its
+	* status, and a draw consumes one chance, so a replay cannot double-spend.
+	*/
+	async redeemStreak(account) {
+		const credential = account.credential;
+		const status = await this.client.growthStreakFull(credential);
+		for (const tier of status.tiers) {
+			if (this.stopped) return;
+			if (tier.status === "locked" || tier.status === "claimed") continue;
+			try {
+				await this.client.redeemStreakTier(credential, tier.tier);
+				this.logger.info?.(`automation streak ${account.label}: redeemed ${tier.tier} (+${tier.credit}c +${tier.energy}e +${tier.chances} draw(s))`);
+				this.recordEarnings(account.id, dayKey(this.now()), { bonusCredit: tier.credit });
+			} catch (error) {
+				this.logger.warn?.(`automation streak ${account.label}: redeem ${tier.tier} failed:`, error);
+			}
+			if (this.delayMs > 0 && !this.stopped) await sleep(this.delayMs);
+		}
+		const chances = await this.client.lotteryChances(credential);
+		for (let draw = 0; draw < chances; draw += 1) {
+			if (this.stopped) return;
+			try {
+				const prize = await this.client.lotteryDraw(credential);
+				this.logger.info?.(`automation lottery ${account.label}: draw ${draw + 1}/${chances} -> ${JSON.stringify(prize).slice(0, 120)}`);
+			} catch (error) {
+				this.logger.warn?.(`automation lottery ${account.label}: draw failed:`, error);
+				break;
+			}
+			if (this.delayMs > 0 && !this.stopped) await sleep(this.delayMs);
+		}
+	}
+	/**
+	* One trip through the buddy travel loop for an account.
+	*
+	* A single pass advances the state machine by at most one step: a trip
+	* that has arrived is collected, and an idle buddy is sent out. A buddy
+	* already travelling is left alone — there is nothing to do until it lands.
+	*
+	* Measured against the live upstream: the departed trip reports
+	* `dailyLimitReached` immediately, so the once-a-day limit needs no local
+	* bookkeeping.
+	*/
+	async runTravel(account) {
+		const credential = account.credential;
+		if (await this.client.buddyInfo(credential) === void 0) {
+			try {
+				await this.client.buddyAgree(credential);
+				await this.client.buddyAdoptFirst(credential);
+				this.logger.info?.(`automation travel ${account.label}: adopted first buddy`);
+			} catch (error) {
+				this.logger.info?.(`automation travel ${account.label}: adoption not available yet (` + String(error).slice(0, 80) + ")");
+			}
+			return;
+		}
+		const travel = await this.client.buddyTravelStatus(credential);
+		if (travel.state === "arrived") {
+			if (travel.recordId === 0) {
+				this.logger.warn?.(`automation travel ${account.label}: arrived but no record id`);
+				return;
+			}
+			const reward = await this.client.buddyTravelClaim(credential, travel.recordId);
+			this.recordEarnings(account.id, dayKey(this.now()), { travelCredit: reward });
+			this.logger.info?.(`automation travel ${account.label}: claimed trip +${reward}c`);
+			return;
+		}
+		if (travel.state === "idle" && !travel.dailyLimitReached) {
+			await this.client.buddyTravelDepart(credential);
+			this.logger.info?.(`automation travel ${account.label}: departed (arrives later, claimed next pass)`);
+			return;
+		}
+		this.logger.info?.(`automation travel ${account.label}: nothing to do (state=${travel.state})`);
+	}
+};
+//#endregion
+//#region src/status.ts
+/** Format the per-model credit multipliers. */
+function formatRates(status) {
+	const lines = ["Model credit multipliers:"];
 	for (const model of status.models) {
 		const rate = model.multiplier === void 0 ? "x?" : `x${model.multiplier.toFixed(2)}`;
 		lines.push(`  ${model.name.padEnd(20)} ${rate}`);
@@ -1310,16 +3476,44 @@ const modelSelectionSchema = z.object({
 	imageModelIds: z.array(z.string()).description("Model ids accepting image input in this region (absent = follow upstream)"),
 	contextBudgets: z.dict(z.number().step(1).min(1)).description("Per-model context-window override for this region")
 });
+/**
+* Automation schema.
+*
+* `enabled` carries a real default (false) because the scheduler reads it on
+* every tick and a missing field must mean "off" rather than "undefined".
+* The hour lists fall back in the scheduler itself, so they stay optional here
+* and an absent list keeps the documented schedule.
+*
+* `exhaustCooldownMs` is mirrored from the pool options: the card offers it as
+* part of the automation block, since how long a spent account rests only
+* matters to the automation that has to work around it.
+*/
+const automationSchema = z.object({
+	enabled: z.boolean().default(false).description("Run the daily points automation"),
+	checkinHours: z.array(z.number().step(1).min(0).max(23)).description("Local hours for the daily check-in"),
+	reportHours: z.array(z.number().step(1).min(0).max(23)).description("Local hours for the activity report (runs before tasks)"),
+	taskHours: z.array(z.number().step(1).min(0).max(23)).description("Local hours for task enrolment and claiming"),
+	streakHours: z.array(z.number().step(1).min(0).max(23)).description("Local hours for streak redemption"),
+	travelHours: z.array(z.number().step(1).min(0).max(23)).description("Local hours for the buddy travel loop"),
+	exhaustCooldownMs: z.number().step(1).min(1e3).description("How long a spent account rests, in milliseconds")
+});
 z.object({
 	authFile: z.string().description("WorkBuddy desktop auth file (defaults to the app own location)"),
 	cooldownMs: z.number().step(1).min(1e3).default(6e4).description("Rate-limit cooldown per account, in milliseconds"),
-	distribution: z.union(["priority", "round-robin"]).default("priority").description("How requests are spread: priority (drain one) or round-robin"),
+	distribution: z.union([
+		"priority",
+		"round-robin",
+		"balanced"
+	]).default("priority").description("How requests are spread: priority (drain one), round-robin (in order), or balanced (idle-weighted random)"),
 	disabledAccountIds: z.array(z.string()).default([]).description("Account ids excluded from the pool (empty = every discovered account participates)"),
+	creditReserves: z.dict(z.number().step(1).min(0)).default({}).description("Per-account credit floor: stop using an account once its balance reaches this value"),
 	enabledModelIds: z.array(z.string()).default([]).description("Legacy shared model-id list; used by a region that has no per-region selection yet"),
 	imageModelIds: z.array(z.string()).default([]).description("Legacy shared image-id list; used by a region that has no per-region selection yet"),
 	contextBudgets: z.dict(z.number().step(1).min(1)).default({}).description("Legacy shared context budgets; used by a region with no per-region selection yet"),
 	modelSelectionCn: modelSelectionSchema.description("Model selection for the domestic gateway"),
-	modelSelectionGlobal: modelSelectionSchema.description("Model selection for the international gateway")
+	modelSelectionGlobal: modelSelectionSchema.description("Model selection for the international gateway"),
+	automation: automationSchema.description("Daily points automation (activity report, task claiming, check-in)"),
+	automationEarnings: z.any().description("Automation earnings ledger (written by the scheduler)")
 });
 /** Assemble the runtime objects without registering anything. */
 /**
@@ -1332,16 +3526,18 @@ z.object({
 */
 function createCore(logger) {
 	const client = new WorkBuddyUpstreamClient();
+	const pool = new WorkBuddyAccountPool({
+		...logger === void 0 ? {} : { logger },
+		client
+	});
 	return {
-		pool: new WorkBuddyAccountPool({
-			...logger === void 0 ? {} : { logger },
-			client
-		}),
+		pool,
 		catalogs: {
 			cn: new WorkBuddyCatalog(),
 			global: new WorkBuddyCatalog()
 		},
-		client
+		client,
+		scheduler: new WorkBuddyScheduler(pool, client, { ...logger === void 0 ? {} : { logger } })
 	};
 }
 //#endregion