dsh-workbuddy-xdpool 1.0.1 → 1.1.0

package/CHANGELOG.md

@@ -4,6 +4,72 @@
 
 版本号遵循 [语义化版本](https://semver.org/lang/zh-CN/)。
 
+## 1.1.0 (2026-09-23)
+
+新增**积分自动化**：插件可以在后台替你完成成长中心的日常动作，不用每天手动点一遍。
+
+### 它是怎么工作的
+
+开启后，调度器每分钟醒一次，到点就跑当天的任务，每个任务每天只跑一次（按本地日期记「今天已跑」，过零点自动重置）。四个任务各有独立的执行时段，默认这样安排：
+
+| 任务 | 默认时段 | 做什么 |
+| --- | --- | --- |
+| 每日签到 | 09:00 | 领取当天签到奖励 |
+| 活跃上报 | 10:00 | 上报一次对话活跃 |
+| 任务奖励 | 11:00 | 报名开放任务 + 领取已达标的奖励 |
+| 连登奖励 | 12:00 | 连登档位兑换 + 抽奖（本轮先占位，下轮接入） |
+
+**为什么上报排在任务之前**：上报会点亮成长中心的任务进度，后跑的任务那一趟才能读到刚涨上去的计数。顺序反了就会出现「进度明明到了却没领到」。这不是随手排的，是实测出来的。
+
+### 一、任务中心自动领取
+
+每个账号走一遍：拉任务列表 → 把还没报名的任务批量报名 → 把已达标的奖励逐个领掉。卡片上汇总显示本次领取了几个任务、加了多少积分。
+
+两个动作都是**幂等**的，重复跑不会重复入账：报名对已报名的任务返回成功，领取对已领过的返回 `already_claimed` 并记为成功。所以某个账号中途失败、下一轮重跑是安全的。
+
+### 二、活跃上报
+
+按客户端 `chat_request_send` 事件的完整形状上报（37 个字段），而不是只发最小几个字段——上游对「字段不全」的表现是**返回 200 然后静默丢弃**，所以字段必须发全，且必须带 `userId`。
+
+上报成功后会回读连登天数做验证。这里有两个实测踩到的坑，都已规避：
+
+- 连登接口的路径**不带 `/v2` 前缀**（和任务的 `/v2/activity/growth/*` 不一样）。用错前缀不会 404，而是返回一个没有 `streak` 字段的响应；
+- 天数藏在 `data.streak.days` 里，读平铺的 `data.days` 会永远得到 0，从而把每一次成功的上报都误报成「静默丢弃」。
+
+另外，连登计数是**异步写入**的：上报后立刻回读可能还是旧值（实测某账号上报瞬间读到 0、一分钟后读到 1）。所以回读为 0 时只记一条提示日志，**不重试**——上报本身按天幂等，反复重发只会浪费每天一次的名额。
+
+### 三、只碰该碰的账号
+
+- **国际版账号全部跳过**：global 域没有成长任务体系，调用只会产生噪声。
+- **你在卡片上关掉的账号跳过**。
+- **正在冷却的账号跳过**。
+- **一个账号失败不影响其他账号**：出错的那个跳过，继续跑下一个，并在汇总里记下失败数量。
+
+账号之间默认间隔 800ms 串行执行，避免一排账号同时打上游。
+
+### 四、卡片上的自动化面板
+
+账号卡片新增「积分自动化」区块：一个开关控制总开关，开启后才展开显示各任务的执行时段和上次执行结果（日期 · 成功数/失败数）。
+
+开关默认**关闭**——后台自动发请求这件事应该是你主动开启的。关闭状态下不会发起任何后台请求。
+
+### 配置
+
+配置项 `automation`，对应卡片上的开关：
+
+| 字段 | 默认 | 说明 |
+| --- | --- | --- |
+| `enabled` | `false` | 总开关 |
+| `checkinHours` | `[9]` | 签到时段 |
+| `reportHours` | `[10]` | 上报时段 |
+| `taskHours` | `[11]` | 任务时段 |
+| `streakHours` | `[12]` | 连登时段 |
+| `exhaustCooldownMs` | 30 分钟 | 账号额度用尽后休息多久 |
+
+### 实测结果
+
+在真实账号上验证了完整链路：4 个国内账号各领到 1 个任务，合计 **+600 积分 +23 能量**；紧接着再跑一次，四个账号全部领取 0、入账 0，确认幂等。上报后任务进度确实从 3/5 涨到 5/5，验证了「上报点亮任务」这一步是真的。
+
 ## 1.0.1 (2026-09-23)
 
 修复两个用号逻辑上的缺陷，并把账号卡片重新排了一遍。

package/lib/bin.js

@@ -286,6 +286,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;
@@ -562,6 +606,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 {
@@ -576,6 +714,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
@@ -1284,6 +1503,311 @@ function catalogFromUpstream(models) {
 	if (models.length === 0) return FALLBACK_WORKBUDDY_MODELS;
 	return models.map(toModelInfo);
 }
+/** 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/status.ts
 /** Format the per-model credit multipliers. */
@@ -1310,6 +1834,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")
+});
 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"),
@@ -1319,7 +1863,8 @@ 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)")
 });
 /** Assemble the runtime objects without registering anything. */
 /**
@@ -1332,16 +1877,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