dsh-workbuddy-xdpool 1.0.0 → 1.1.0

package/lib/index.js

@@ -302,6 +302,50 @@ 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.
+*/
+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;
@@ -578,6 +622,100 @@ var WorkBuddyUpstreamClient = class {
 			isStreakDay: data["is_streak_day"] === true
 		};
 	}
+	/**
+	* 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.
+	*/
+	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;
+	}
 	/** Legacy thin wrapper kept for `status`/`doctor`: returns raw envelope data. */
 	async credits(credential) {
 		try {
@@ -592,6 +730,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
@@ -794,10 +1013,18 @@ function idleWeight(lastUsedAt, now) {
 	const hours = (now - lastUsedAt) / 36e5;
 	return 1 + Math.min(Math.max(hours, 0) * IDLE_WEIGHT_PER_HOUR, IDLE_WEIGHT_MAX);
 }
+/** Default rest for an account whose credits ran out (packs reset on their own schedule). */
+const EXHAUST_COOLDOWN_MS = 18e5;
 var WorkBuddyAccountPool = class {
 	logger;
 	authDirs;
 	cooldownMs;
+	/**
+	* How long an account stays out of rotation after the upstream reports its
+	* credits are spent. Credit packs reset on their own schedule rather than on a
+	* rate-limit window, so this is much longer than `cooldownMs`.
+	*/
+	exhaustCooldownMs;
 	client;
 	refreshMarginMs;
 	accounts = [];
@@ -829,6 +1056,7 @@ var WorkBuddyAccountPool = class {
 		this.logger = options.logger;
 		this.authDirs = options.authDirs ?? candidateAuthDirs();
 		this.cooldownMs = options.cooldownMs ?? 6e4;
+		this.exhaustCooldownMs = options.exhaustCooldownMs ?? EXHAUST_COOLDOWN_MS;
 		this.client = options.client;
 		this.refreshMarginMs = options.refreshMarginMs ?? 3e5;
 		this.distribution = options.distribution ?? "priority";
@@ -841,6 +1069,7 @@ var WorkBuddyAccountPool = class {
 	applyConfig(options) {
 		if (options.authDirs !== void 0 && options.authDirs.length > 0) this.authDirs = options.authDirs;
 		if (options.cooldownMs !== void 0 && options.cooldownMs >= 1e3) this.cooldownMs = options.cooldownMs;
+		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);
 	}
@@ -967,14 +1196,12 @@ var WorkBuddyAccountPool = class {
 		if (this.preferredId !== void 0) {
 			const preferred = pool.find((account) => account.id === this.preferredId);
 			if (preferred !== void 0) {
-				this.lastUsedAt.set(preferred.id, Date.now());
 				await this.ensureFresh(preferred);
 				return preferred;
 			}
 		}
 		const account = this.distribution === "round-robin" ? this.pickRoundRobin(pool) : this.distribution === "balanced" ? this.pickByWeight(pool) : pool[0];
 		if (account === void 0) return void 0;
-		this.lastUsedAt.set(account.id, Date.now());
 		await this.ensureFresh(account);
 		return account;
 	}
@@ -994,6 +1221,40 @@ var WorkBuddyAccountPool = class {
 	disabledIdsInOrder() {
 		return this.accounts.filter((account) => this.disabledIds.has(account.id)).map((account) => account.id);
 	}
+	/**
+	* Record that an account actually served a request.
+	*
+	* Called by the shim once the upstream answers 200 — only then is the account
+	* the one the user is really being served by. `balanced` mode reads the same map
+	* for its idle weighting, so a request that failed over to another account must
+	* not count as used for the account that was merely tried.
+	*/
+	noteServed(accountId) {
+		if (!this.accounts.some((account) => account.id === accountId)) return;
+		this.lastUsedAt.set(accountId, Date.now());
+	}
+	/**
+	* The account that served the most recent request, if any.
+	*
+	* Distinct from "who would serve the next one": this is a record of what
+	* actually happened, which is what the card needs to answer "which account am
+	* I using right now?". Under `balanced` there is no deterministic next account
+	* at all, so a recorded fact is the only honest answer.
+	*
+	* Returns undefined before the first request of the process, and after every
+	* known account has been re-scanned away (a login swapped out under us).
+	*/
+	lastServedId() {
+		let newest;
+		for (const [id, at] of this.lastUsedAt) {
+			if (!this.accounts.some((account) => account.id === id)) continue;
+			if (newest === void 0 || at > newest.at) newest = {
+				id,
+				at
+			};
+		}
+		return newest?.id;
+	}
 	/** Best-effort refresh of one account after a session-dead upstream answer. */
 	async refreshAccount(accountId) {
 		const account = this.accounts.find((item) => item.id === accountId);
@@ -1044,6 +1305,23 @@ var WorkBuddyAccountPool = class {
 		}
 	}
 	/**
+	* Cool a whole account after the upstream reports its credits are spent.
+	*
+	* Credit exhaustion is an ACCOUNT condition, unlike a model rate limit: every
+	* model on that account is unusable until the quota resets, so this cools the
+	* account as a whole (no `modelId`) for the configured exhaustion window. The
+	* shim then rotates to a different account instead of failing the request.
+	*/
+	penalizeExhausted(accountId) {
+		const until = Date.now() + this.exhaustCooldownMs;
+		this.penalize(accountId, until);
+		this.logger?.warn(`
+dsh-workbuddy-xdpool: account credits exhausted; cooling the whole account until 
+
+${new Date(until).toISOString()}
+`);
+	}
+	/**
 	* Mark an account (or one of its models) rate-limited.
 	*
 	* With `modelId`, only that model on the account is cooled — the account's
@@ -1436,6 +1714,311 @@ function createWorkBuddyAdapter(options) {
 		}
 	};
 }
+/** How often the loop wakes to look for a due job. */
+const AUTOMATION_TICK_MS = 6e4;
+const JOB_KINDS = [
+	"checkin",
+	"report",
+	"tasks",
+	"streak"
+];
+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. */
+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;
+	enabled;
+	checkinHours;
+	taskHours;
+	reportHours;
+	streakHours;
+	timer;
+	running = false;
+	/** Guards against a slow run overlapping the next tick. */
+	busy = 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 }
+	};
+	claimableSeen = 0;
+	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.enabled = options.enabled ?? false;
+		this.checkinHours = options.checkinHours ?? [9];
+		this.reportHours = options.reportHours ?? [10];
+		this.taskHours = options.taskHours ?? [11];
+		this.streakHours = options.streakHours ?? [12];
+	}
+	/** Apply a new configuration; safe to call while running. */
+	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;
+	}
+	/** 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;
+		}
+	}
+	/** 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. */
+	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,
+			jobs,
+			claimableSeen: this.claimableSeen
+		};
+	}
+	/**
+	* 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. */
+	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();
+		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":
+						await this.client.claimDailyCheckin(account.credential);
+						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.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);
+				}
+				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;
+		}
+	}
+	/**
+	* 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 tasks = await this.client.listTasks(credential);
+		const open = tasks.filter((task) => task.acceptStatus === "not_accepted" && !task.locked).map((task) => task.taskCode);
+		if (open.length > 0) await this.client.acceptTasks(credential, open);
+		const claimable = (open.length > 0 ? await this.client.listTasks(credential) : tasks).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 and lottery.
+	*
+	* Left as a deliberate no-op placeholder: the tier/lottery endpoints need
+	* their own round of probing against the live upstream before they can be
+	* wired safely, and a wrong call here could burn a redemption. The job slot,
+	* scheduling and status plumbing already exist, so filling it in is a
+	* self-contained change.
+	*/
+	async redeemStreak(account) {
+		this.logger.info?.(`automation streak ${account.label}: not implemented yet (skipped)`);
+	}
+};
 //#endregion
 //#region src/shim.ts
 /**
@@ -1655,6 +2238,7 @@ function createWorkBuddyShim(options) {
 			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);
 				res.writeHead(200, {
 					"Content-Type": "text/event-stream",
 					"Cache-Control": "no-cache",
@@ -1683,6 +2267,11 @@ function createWorkBuddyShim(options) {
 				await pool.refreshAccount(account.id);
 				continue;
 			}
+			if (result.kind === "hard_credit") {
+				pool.penalizeExhausted(account.id);
+				logger?.warn(`dsh-workbuddy-xdpool: ${account.label} has no credits left (attempt ${attempt + 1}/${maxAttempts}); rotating`);
+				continue;
+			}
 			if (result.kind !== "soft_rate") break;
 			exhaustedByRateLimit = true;
 			pool.penalize(account.id, parseRateLimitReset(result.message), modelId);
@@ -1826,6 +2415,21 @@ const POOL_ACCOUNT_DISABLE_PATH = "/plugins/dsh-workbuddy-xdpool/accounts/disabl
 //#endregion
 //#region src/web-status.ts
 /** Redact token-like content before it crosses to the browser. */
+/**
+* A zeroed-out automation job record.
+*
+* Used when no scheduler is wired: the card renders the same shape either way,
+* so an unwired profile shows zeroes rather than a missing panel.
+*/
+function emptyAutomationJob() {
+	return {
+		ok: 0,
+		failed: 0,
+		credit: 0,
+		energy: 0,
+		claimed: 0
+	};
+}
 function safeMessage(error) {
 	return (error instanceof Error ? error.message : String(error)).replace(/\beyJ[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\b/gu, "[redacted token]").replace(/(\b(?:code|token|refresh_token|access_token)=)[^&\s]+/giu, "$1[redacted]").slice(0, 500);
 }
@@ -2014,7 +2618,8 @@ async function poolWebStatus(deps, region = "cn") {
 		rows.push(row);
 	}
 	const cooling = rows.filter((row) => row.cooling).length;
-	const firstUsable = accounts.find((account) => account.cooldownUntilMs <= now);
+	const lastServed = deps.pool.lastServedId();
+	const firstUsable = lastServed !== void 0 ? accounts.find((account) => account.id === lastServed) : accounts.find((account) => account.cooldownUntilMs <= now);
 	let shim;
 	if (deps.shim === void 0) shim = { running: false };
 	else try {
@@ -2022,6 +2627,21 @@ async function poolWebStatus(deps, region = "cn") {
 	} catch {
 		shim = { running: false };
 	}
+	const automation = deps.scheduler?.() ?? {
+		enabled: false,
+		running: false,
+		checkinHours: [],
+		reportHours: [],
+		taskHours: [],
+		streakHours: [],
+		jobs: {
+			checkin: emptyAutomationJob(),
+			report: emptyAutomationJob(),
+			tasks: emptyAutomationJob(),
+			streak: emptyAutomationJob()
+		},
+		claimableSeen: 0
+	};
 	return {
 		ok: accounts.length > 0 && cooling < accounts.length,
 		accounts: rows,
@@ -2042,7 +2662,8 @@ async function poolWebStatus(deps, region = "cn") {
 		region,
 		distribution: deps.pool.currentDistribution(),
 		regions,
-		shim
+		shim,
+		automation
 	};
 }
 /**
@@ -2198,6 +2819,22 @@ const WORKBUDDY_POOL_SETTINGS_NS = "workbuddy-xdpool";
 /** Upper bound the card offers as the "default" context window, in tokens. */
 const DEFAULT_CONTEXT_BUDGET = 2e5;
 /**
+* Fold a saved automation block into scheduler options.
+*
+* Absent means off, stated once here so every caller agrees: the card writes
+* `enabled` as a real boolean, and a config that never touched the section must
+* not accidentally arm background upstream traffic.
+*/
+function automationOptions(automation) {
+	return {
+		enabled: automation?.enabled === true,
+		...automation?.checkinHours === void 0 ? {} : { checkinHours: automation.checkinHours },
+		...automation?.reportHours === void 0 ? {} : { reportHours: automation.reportHours },
+		...automation?.taskHours === void 0 ? {} : { taskHours: automation.taskHours },
+		...automation?.streakHours === void 0 ? {} : { streakHours: automation.streakHours }
+	};
+}
+/**
 * One region's model-selection schema.
 *
 * Every field is optional on purpose: an absent field keeps its documented
@@ -2210,6 +2847,26 @@ 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"),
+	exhaustCooldownMs: z.number().step(1).min(1e3).description("How long a spent account rests, in milliseconds")
+});
 /** Settings key holding one region's saved selection. */
 const modelSelectionKeyFor = (region) => region === "cn" ? "modelSelectionCn" : "modelSelectionGlobal";
 /**
@@ -2231,7 +2888,8 @@ const Config = z.object({
 	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)")
 });
 /** Live API, published for the CLI. */
 let api;
@@ -2254,16 +2912,18 @@ function setApi(next) {
 */
 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 } })
 	};
 }
 /**
@@ -2296,12 +2956,13 @@ function apply(ctx, config = {}) {
 		}
 	};
 	const applyConfigFromSource = () => {
-		const { authFile, cooldownMs, distribution, disabledAccountIds, enabledModelIds, imageModelIds, contextBudgets, modelSelectionCn, modelSelectionGlobal } = current();
+		const { authFile, cooldownMs, distribution, disabledAccountIds, enabledModelIds, imageModelIds, contextBudgets, modelSelectionCn, modelSelectionGlobal, automation } = current();
 		core.pool.applyConfig({
 			...authFile === void 0 ? {} : { authDirs: [dirname(authFile)] },
 			...cooldownMs === void 0 ? {} : { cooldownMs },
 			distribution: distribution ?? "priority",
-			...disabledAccountIds === void 0 ? {} : { disabledAccountIds }
+			...disabledAccountIds === void 0 ? {} : { disabledAccountIds },
+			...automation?.exhaustCooldownMs === void 0 ? {} : { exhaustCooldownMs: automation.exhaustCooldownMs }
 		});
 		const legacySelection = {
 			...enabledModelIds === void 0 ? {} : { enabledModelIds },
@@ -2310,6 +2971,7 @@ function apply(ctx, config = {}) {
 		};
 		core.catalogs.cn.applySelection(modelSelectionCn ?? legacySelection);
 		core.catalogs.global.applySelection(modelSelectionGlobal ?? legacySelection);
+		core.scheduler.applyConfig(automationOptions(automation));
 	};
 	const settingsService = ctx.settings;
 	if (typeof settingsService.installSection === "function") settingsService.installSection(ctx, WORKBUDDY_POOL_SETTINGS_NS, Config, config, sectionHooks);
@@ -2319,14 +2981,30 @@ function apply(ctx, config = {}) {
 	* the three model-selection keys, so the settings file cannot be steered from
 	* the browser; the catalog re-reads through `onChange` either way.
 	*/
+	/**
+	* Write one key of the plugin's own settings section. Only ever called with the
+	* model-selection keys, the distribution, and the disabled-account list, so the
+	* settings file cannot be steered from the browser; the catalogs and the pool
+	* re-read through `onChange` either way.
+	*
+	* `set` returns a promise, so a rejection must be caught explicitly: a bare
+	* `void write.call(...)` swallows it, and the card then looks like it saved
+	* while the value never reached the settings file.
+	*/
 	const setSetting = (key, value) => {
 		if (value === void 0) return;
 		const write = settingsService?.set;
-		if (write === void 0) return;
+		if (write === void 0) {
+			ctx.logger.warn?.(`dsh-workbuddy-xdpool: no settings writer; ` + key + ` was not saved`);
+			return;
+		}
 		try {
-			write.call(settingsService, key, value);
+			const result = write.call(settingsService, key, value);
+			if (result !== void 0 && typeof result.then === "function") result.catch((error) => {
+				ctx.logger.warn?.(`dsh-workbuddy-xdpool: failed to persist ` + key, error);
+			});
 		} catch (error) {
-			ctx.logger.warn?.(`dsh-workbuddy-xdpool: failed to persist ${key}`, error);
+			ctx.logger.warn?.(`dsh-workbuddy-xdpool: failed to persist ` + key, error);
 		}
 	};
 	const shims = {
@@ -2362,12 +3040,14 @@ function apply(ctx, config = {}) {
 		stopped = true;
 		shims.cn.close();
 		shims.global.close();
+		core.scheduler.stop();
 	});
 	ctx.inject(["webServer"], (webCtx) => registerPoolStatusRoute(webCtx, {
 		pool: core.pool,
 		catalogs: core.catalogs,
 		client: core.client,
 		shim: () => shimInfo("cn"),
+		scheduler: () => core.scheduler.status(),
 		saveSelection: (region, selection) => {
 			setSetting(modelSelectionKeyFor(region), {
 				...selection.enabledModelIds === void 0 ? {} : { enabledModelIds: [...selection.enabledModelIds] },
@@ -2405,6 +3085,7 @@ function apply(ctx, config = {}) {
 			core.pool.resetCooldowns();
 		}
 	};
+	core.scheduler.start();
 	Promise.all([shims.cn.ready, shims.global.ready]).then(async () => {
 		if (stopped) return;
 		try {
@@ -2509,4 +3190,4 @@ function apply(ctx, config = {}) {
 	});
 }
 //#endregion
-export { Config, DEFAULT_CONTEXT_BUDGET, FALLBACK_WORKBUDDY_MODELS, POOL_CHECKIN_PATH, POOL_MODELS_SAVE_PATH, POOL_RESCAN_PATH, POOL_RESET_COOLDOWN_PATH, POOL_STATUS_PATH, WORKBUDDY_AUTH_FILE_ENV, WORKBUDDY_LIVE_FILENAME, WORKBUDDY_POOL_PROVIDER, WORKBUDDY_POOL_SETTINGS_NS, WorkBuddyAccountPool, WorkBuddyCatalog, WorkBuddyUpstreamClient, apply, buildStatus, candidateAuthDirs, classifyUpstreamError, createCore, createWorkBuddyAdapter, createWorkBuddyShim, currentApi, defaultDesktopAuthDirs, formatRates, formatStatus, inject, modelSelectionKeyFor, name, parseRateLimitReset, parseWorkBuddyAuth, setApi, workbuddyAccountId };
+export { Config, DEFAULT_CONTEXT_BUDGET, FALLBACK_WORKBUDDY_MODELS, POOL_CHECKIN_PATH, POOL_MODELS_SAVE_PATH, POOL_RESCAN_PATH, POOL_RESET_COOLDOWN_PATH, POOL_STATUS_PATH, WORKBUDDY_AUTH_FILE_ENV, WORKBUDDY_LIVE_FILENAME, WORKBUDDY_POOL_PROVIDER, WORKBUDDY_POOL_SETTINGS_NS, WorkBuddyAccountPool, WorkBuddyCatalog, WorkBuddyUpstreamClient, apply, automationOptions, buildStatus, candidateAuthDirs, classifyUpstreamError, createCore, createWorkBuddyAdapter, createWorkBuddyShim, currentApi, defaultDesktopAuthDirs, formatRates, formatStatus, inject, modelSelectionKeyFor, name, parseRateLimitReset, parseWorkBuddyAuth, setApi, workbuddyAccountId };