@khaosoigai/pi-ds-pricing-regime 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 khaosoigai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,166 @@
+# pi-ds-pricing-regime
+
+A [pi](https://github.com/earendil-works/pi-coding-agent) extension that shows
+whether DeepSeek is currently in **peak** or **off-peak** billing mode, in the
+bottom-left of the footer. It reads the machine's clock, so all boundary times
+display in the machine's local timezone — nothing is hardcoded.
+
+## What it shows
+
+| State | Footer text (bottom-left) |
+| --- | --- |
+| Peak hours | `⚡ DeepSeek PEAK — until 12:00 local` (amber) |
+| Off-peak | `🌙 DeepSeek off-peak — next peak 09:00 local` (green) |
+| Weekend (Beijing time) | `🌙 DeepSeek off-peak (weekend flat rate) — next peak Monday 09:00 local` (green) |
+
+When the next boundary is not today (e.g. on a weekend morning), the label
+includes the boundary's local weekday so `09:00` is not mistaken for today's
+clock time.
+
+The status refreshes every 30s, so it flips exactly at hour boundaries.
+
+The indicator is shown **only while the selected model comes from the DeepSeek
+provider** (`ctx.model.provider === "deepseek"`) — the regime is DeepSeek API
+pricing, so it is meaningless for other providers. Switching models with
+`/model` or `Ctrl+P` clears or restores the status immediately. The provider id
+is a constant (`DEEPSEEK_PROVIDER`) at the top of the extension.
+
+## Pairing with a configurable footer
+
+The extension publishes plain pi statuses (`ctx.ui.setStatus`), so it works
+with the **built-in footer** out of the box — no companion extension required.
+It publishes two keys, sorted alphabetically there:
+
+| Status key | Shows |
+| --- | --- |
+| `zz-deepseek-regime` | `⚡ DeepSeek PEAK — until 12:00 local` (see table above) |
+| `zz-deepseek-balance` | `💰 ¥12.34` — DeepSeek platform credit balance, warning-coloured under the `LOW_BALANCE` thresholds |
+
+For a configurable multi-line footer we recommend
+[pi-footer](https://github.com/wobondar/pi-footer) (`pi install
+npm:pi-footer`). It renders any published status through its `external-status`
+widget, so this extension needs no changes — add widgets keyed to the status
+keys above on their own line, e.g. `Tavily: 73%` (from a usage tracker) →
+regime → balance, ordered exactly as configured and hidden when empty. Hide
+the same keys from pi-footer's automatic extension-status row
+(`extensionStatusRow.hiddenKeys` in `~/.pi/agent/extensions/pi-footer.json`)
+to avoid showing them twice. Removing pi-footer (`pi remove npm:pi-footer`)
+restores the built-in footer with these statuses intact.
+
+## The regime
+
+Source: [DeepSeek API pricing](https://api-docs.deepseek.com/quick_start/pricing)
+
+- **Peak hours (UTC):** `01:00–04:00` and `06:00–10:00`; all other hours are
+  off-peak at half the peak rates.
+- **Live since:** `2026-08-16T16:00:00Z` (before that, billing was flat).
+- **Weekends:** since `2026-08-22T16:00:00Z` (= 2026-08-23 00:00 Beijing), Saturdays and
+  Sundays in Beijing calendar time have no peak tiers — every call bills at the uniform
+  off-peak rate. The next peak after a live weekend is Monday 01:00 UTC; late UTC Sunday
+  evenings are already Monday in Beijing, so weekday rules resume there.
+
+All are constants at the top of
+[`extensions/deepseek-peak-offpeak.ts`](extensions/deepseek-peak-offpeak.ts)
+(`PEAK_WINDOWS`, `WEEKEND_OFFPEAK_UTC`, `DEEPSEEK_PROVIDER`) — edit them if
+DeepSeek changes the regime.
+
+## Install
+
+Install as a pi package from npm:
+
+```sh
+pi install npm:@khaosoigai/pi-ds-pricing-regime
+```
+
+The package is structured as a pi package: `package.json` declares a
+[`pi` manifest](https://pi.dev/docs/packages) loading `./extensions`, and the
+package is listed with the `pi-package` keyword for the [package gallery](https://pi.dev/packages).
+
+### From git (alternative)
+
+The source repo can also be installed directly over SSH (works because the
+repo is private and SSH keys are configured):
+
+```sh
+pi install git:git@github.com:khaosoi/pi-ds-pricing-regime
+```
+
+Pi clones it to `~/.pi/agent/git/github.com/khaosoi/pi-ds-pricing-regime/` and
+runs `npm install` there; restart pi (or `/reload`) to load it. The settings
+entry has no pinned ref, so `pi update --extensions` pulls latest `main`.
+Pin a ref with `pi install git:git@github.com:khaosoi/pi-ds-pricing-regime@<ref>`.
+
+> Alternative: copy `extensions/deepseek-peak-offpeak.ts` into `.pi/extensions/`
+> of a project for a project-local install.
+
+## Development
+
+```sh
+just format       # format TypeScript, JavaScript, JSON, and config files
+just format-check # verify formatting without changing files
+just lint         # run Biome lint rules
+just check        # format-check + lint
+just build        # check + typecheck + tests — the release gate
+just typecheck    # tsc against pi's types (resolved via the peer dep in node_modules)
+just test         # node:test — unit, smoke, and timezone matrix tests
+just coverage     # run tests with Node's built-in coverage report (100% currently)
+just pack         # npm pack --dry-run: inspect the future tarball
+```
+
+Biome formats and lints TypeScript, JavaScript, JSON, and configuration files.
+The Markdown documentation and `justfile` are intentionally outside these
+recipes. Or use the equivalent npm scripts directly (`npm run format`,
+`npm run format:check`, `npm run lint`, `npm run check`, `npm test`, and
+`npm run coverage`).
+
+No test framework is needed: Node ≥ 23 runs the TypeScript sources directly
+(type stripping), and tests use the built-in `node:test` runner. Tests never
+modify the operating system clock; clock-dependent tests use only Node's
+process-local virtual timers.
+
+- `test/regime.test.ts` — window boundaries, next-boundary math, weekend
+  flat-rate rule.
+- `test/smoke.test.ts` — loads the real extension with a mock pi context and
+  mocked timers: peak / off-peak / weekend status text, and timer lifecycle.
+- `test/timezone-matrix.test.ts` — runs `scripts/timezone-matrix.mjs` under
+  fixed-offset zones (UTC+8, UTC+10, UTC-5) and real DST zones
+  (America/New_York, Australia/Sydney), asserting exact local-time labels
+  including the midnight wrap to the next day's peak and regime boundaries
+  that land on DST transition instants.
+
+CI (`.github/workflows/ci.yml`) runs formatting/lint checks, typecheck, and
+41 tests on Node 24 for every push/PR.
+
+## Publishing
+
+The package is published to npm as `@khaosoigai/pi-ds-pricing-regime`. The
+metadata is already in place:
+
+- scoped name `@khaosoigai/pi-ds-pricing-regime` (name reserved to your npm account)
+- MIT license (`LICENSE` + `license` field)
+- `repository`/`bugs`/`homepage` point at `github.com/khaosoi/pi-ds-pricing-regime`
+  — adjust if the repo gets a different name
+- `publishConfig.access: "public"` so the scoped package publishes publicly
+- `prepublishOnly` gate: runs typecheck + tests before every publish
+
+To release a new version:
+
+1. `npm run preview:package` — confirm the tarball contains only `extensions/`,
+   `LICENSE`, `README.md`
+2. Bump `version` in `package.json`
+3. Merge to `main` and tag the release
+4. `npm login` (account `khaosoigai`) and `npm publish` — the `prepublishOnly`
+   gate re-runs check, typecheck, and tests as the final safety net
+
+## Notes
+
+- Labels show the *next regime boundary* in local time, not the full schedule,
+  to keep the footer compact (e.g. `until 12:00 local` rather than
+  `09:00–12:00, 14:00–18:00`).
+- Boundary labels are rendered from the boundary's *actual instant*
+  (`nextBoundaryUtc` → `formatLocalTime`), so they stay correct even when a
+  DST transition falls between now and the boundary (covered by the DST
+  scenarios in the timezone matrix).
+- A boundary on a later local date is prefixed with its local weekday name
+  (`formatLocalDayPrefix`), so Saturday morning reads `next peak Monday 09:00
+  local` rather than a bare `09:00` that looks like today.

package/extensions/deepseek-peak-offpeak.ts

@@ -0,0 +1,294 @@
+/**
+ * DeepSeek Peak / Off-Peak Footer Indicator
+ *
+ * Shows in the footer (bottom-left) whether DeepSeek is currently in
+ * peak or off-peak billing, computed from the machine's local clock.
+ * All boundary times in the status are shown in the machine's local
+ * timezone — no timezone is hardcoded.
+ *
+ * A second status shows the DeepSeek platform credit balance (fetched from
+ * api.deepseek.com/user/balance with the provider's resolved API key, cached
+ * and throttled to BALANCE_REFRESH_MS). It is likewise only shown while a
+ * DeepSeek model is selected; switching models clears or restores both.
+ *
+ * The status is only displayed while the selected model comes from the
+ * DeepSeek provider (`ctx.model.provider === "deepseek"`); switching models
+ * clears or restores it immediately.
+ *
+ * DeepSeek's regime (per api-docs.deepseek.com/quick_start/pricing):
+ *   Peak hours (UTC): 01:00–04:00 and 06:00–10:00
+ *   All other hours are off-peak (half the peak rates).
+ *   Peak/off-peak billing has been live since 2026-08-16T16:00:00Z.
+ *
+ *   Since 2026-08-22T16:00:00Z (= 2026-08-23 00:00 Beijing), Saturdays and
+ *   Sundays (Beijing calendar time) have no peak tiers at all: every call
+ *   is billed at the uniform off-peak rate.
+ */
+
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+/** Peak windows as [start, end) UTC hours. Edit here if DeepSeek changes the regime. */
+export const PEAK_WINDOWS: ReadonlyArray<readonly [number, number]> = [
+	[1, 4], // 01:00–04:00 UTC
+	[6, 10], // 06:00–10:00 UTC
+];
+
+/**
+ * Weekend flat-rate rule: from 2026-08-22T16:00:00Z (2026-08-23 00:00
+ * Beijing), Saturdays and Sundays in Beijing time are off-peak all day.
+ */
+export const WEEKEND_OFFPEAK_UTC = Date.UTC(2026, 7, 22, 16, 0, 0);
+
+/** Provider id whose models the billing indicator is shown for. Edit here if the provider id changes. */
+export const DEEPSEEK_PROVIDER = "deepseek";
+
+/** China observes a fixed UTC+8 offset year-round (no DST). */
+const BEIJING_OFFSET_MS = 8 * 3_600_000;
+const DAY_MS = 86_400_000;
+
+// Pi's footer sorts extension statuses alphabetically by key, left to right.
+// "zz-" prefix keeps these statuses right of others (e.g. "tavily-usage" stays
+// on the left margin). The keys are never displayed — only the status text.
+export const STATUS_KEY = "zz-deepseek-regime";
+export const BALANCE_KEY = "zz-deepseek-balance";
+const REFRESH_MS = 30_000; // refresh a few times per minute so the local-time label stays current
+
+/** DeepSeek platform origin for the balance API (api-docs.deepseek.com/api-create-user-balance). */
+export const BALANCE_ORIGIN = "https://api.deepseek.com";
+/** Minimum interval between balance API calls. The balance only changes when credits are granted or topped up, so a few minutes is ample. */
+export const BALANCE_REFRESH_MS = 5 * 60_000;
+/** Balance colour thresholds in native currency units; currencies not listed fall back to FALLBACK_LOW_BALANCE. */
+export const LOW_BALANCE: Readonly<Record<string, number>> = { CNY: 20, USD: 5 };
+export const FALLBACK_LOW_BALANCE = 10;
+/** Currency code → symbol; currencies not listed render as "12.34 EUR". */
+const CURRENCY_SYMBOLS: Readonly<Record<string, string>> = { CNY: "¥", USD: "$" };
+
+/** True when `now` falls on a Saturday or Sunday in Beijing calendar time. */
+export function isWeekendBeijing(now: Date): boolean {
+	const day = new Date(now.getTime() + BEIJING_OFFSET_MS).getUTCDay();
+	return day === 0 || day === 6;
+}
+
+/**
+ * True when `now` (UTC) falls inside a peak window.
+ * Once the weekend rule is live (WEEKEND_OFFPEAK_UTC), Saturdays and Sundays
+ * in Beijing time never peak. Before that instant the legacy tiered schedule
+ * applied every day of the week.
+ */
+export function inPeak(now: Date): boolean {
+	if (now.getTime() >= WEEKEND_OFFPEAK_UTC && isWeekendBeijing(now)) return false;
+	const hour = now.getUTCHours();
+	return PEAK_WINDOWS.some(([start, end]) => hour >= start && hour < end);
+}
+
+/**
+ * The next regime boundary after `now`, as a UTC hour (0–23), assuming the
+ * weekday tiered schedule (used for the peak → end-of-window computation).
+ * - If currently peak: the end of the current peak window.
+ * - If currently off-peak: the start of the next peak window (wrapping to tomorrow).
+ */
+export function nextBoundaryUtcHour(now: Date): number {
+	const minute = now.getUTCHours() * 60 + now.getUTCMinutes();
+	const boundaries = inPeak(now)
+		? PEAK_WINDOWS.map(([, end]) => end * 60)
+		: PEAK_WINDOWS.map(([start]) => start * 60);
+	const next = boundaries.find((b) => b > minute);
+	return Math.floor((next ?? boundaries[0]) / 60);
+}
+
+/** "HH:MM" wall-clock for an instant, in the machine's local timezone. */
+export function formatLocalTime(at: Date): string {
+	const hh = String(at.getHours()).padStart(2, "0");
+	const mm = String(at.getMinutes()).padStart(2, "0");
+	return `${hh}:${mm}`;
+}
+
+const DAY_NAMES = ["Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"] as const;
+
+/**
+ * "" when `at` falls on the same local calendar date as `now`; otherwise the
+ * English weekday name of `at` followed by a space (e.g. "Monday "). Used so a
+ * boundary that is not today is not mistaken for today's clock time — e.g. on
+ * Saturday morning the next peak reads "Monday 09:00 local", not "09:00 local".
+ */
+export function formatLocalDayPrefix(now: Date, at: Date): string {
+	const sameLocalDay =
+		now.getFullYear() === at.getFullYear() && now.getMonth() === at.getMonth() && now.getDate() === at.getDate();
+	return sameLocalDay ? "" : `${DAY_NAMES[at.getDay()]} `;
+}
+
+/**
+ * The next regime boundary after `now`, as an absolute UTC instant.
+ * Peak → end of the current window; off-peak → start of the next window,
+ * scanning forward over UTC days (up to `maxScanDays`) while skipping
+ * candidate instants that fall on a live Beijing weekend (the next peak after
+ * Friday is Monday 01:00 UTC). Uses `now`'s own date, so the local-time label
+ * stays correct even when a DST transition falls between `now` and the
+ * boundary.
+ */
+export function nextBoundaryUtc(now: Date, maxScanDays = 9): Date {
+	const dayStart = Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate());
+	if (inPeak(now)) {
+		return new Date(dayStart + nextBoundaryUtcHour(now) * 3_600_000);
+	}
+	for (let d = 0; d < maxScanDays; d++) {
+		const utcDayStart = dayStart + d * DAY_MS;
+		for (const [start] of PEAK_WINDOWS) {
+			const at = utcDayStart + start * 3_600_000;
+			if (at <= now.getTime()) continue;
+			if (at >= WEEKEND_OFFPEAK_UTC && isWeekendBeijing(new Date(at))) continue;
+			return new Date(at);
+		}
+	}
+	throw new Error("no peak window found within the next 9 days");
+}
+
+/**
+ * True when the given model (e.g. `ctx.model`) is served by the DeepSeek
+ * provider, i.e. when the peak/off-peak regime actually applies to it.
+ */
+export function isDeepSeekModel(model: { provider?: string } | undefined | null): boolean {
+	return model?.provider === DEEPSEEK_PROVIDER;
+}
+
+/**
+ * Parse a DeepSeek `/user/balance` response body into the first balance entry.
+ * Returns undefined when the shape is not as documented (proxy response, API
+ * change, error JSON) so callers can keep showing the previous value.
+ */
+export function parseBalance(body: unknown): { total: number; currency: string; isAvailable: boolean } | undefined {
+	if (typeof body !== "object" || body === null) return undefined;
+	const record = body as Record<string, unknown>;
+	const infos = Array.isArray(record.balance_infos) ? record.balance_infos : [];
+	const info = infos[0];
+	if (typeof info !== "object" || info === null) return undefined;
+	const entry = info as Record<string, unknown>;
+	const total = Number(entry.total_balance);
+	if (!Number.isFinite(total)) return undefined;
+	return {
+		total,
+		currency: typeof entry.currency === "string" ? entry.currency : "",
+		isAvailable: record.is_available !== false,
+	};
+}
+
+/**
+ * The rendered balance status: "💰 ¥12.34", low-balances in the theme's
+ * warning colour. Precision: integers lose the decimals ("¥12"), anything
+ * else keeps two. Unknown currencies render as "12.34 EUR".
+ */
+export function formatBalance(balance: { total: number; currency: string }): {
+	text: string;
+	low: boolean;
+} {
+	const { total, currency } = balance;
+	const amount = Number.isInteger(total) ? String(total) : total.toFixed(2);
+	const symbol = CURRENCY_SYMBOLS[currency];
+	const text = symbol ? `💰 ${symbol}${amount}` : `💰 ${amount}${currency ? ` ${currency}` : ""}`;
+	const threshold = LOW_BALANCE[currency] ?? FALLBACK_LOW_BALANCE;
+	return { text, low: total < threshold };
+}
+
+/** The status text for `now`, or undefined to clear the status. */
+export function statusText(now: Date): { text: string; color: "warning" | "success" } {
+	const boundary = nextBoundaryUtc(now);
+	const label = `${formatLocalDayPrefix(now, boundary)}${formatLocalTime(boundary)}`;
+	if (inPeak(now)) {
+		return { color: "warning", text: `⚡ DeepSeek PEAK — until ${label} local` };
+	}
+	if (now.getTime() >= WEEKEND_OFFPEAK_UTC && isWeekendBeijing(now)) {
+		return {
+			color: "success",
+			text: `🌙 DeepSeek off-peak (weekend flat rate) — next peak ${label} local`,
+		};
+	}
+	return {
+		color: "success",
+		text: `🌙 DeepSeek off-peak — next peak ${label} local`,
+	};
+}
+
+export default function (pi: ExtensionAPI) {
+	let timer: ReturnType<typeof setInterval> | undefined;
+	let balance: { text: string; low: boolean } | undefined;
+	let lastFetched = 0;
+	let inflight: Promise<void> | undefined;
+
+	const applyBalance = (ctx: ExtensionContext) => {
+		if (balance) {
+			ctx.ui.setStatus(BALANCE_KEY, ctx.ui.theme.fg(balance.low ? "warning" : "success", balance.text));
+		} else {
+			ctx.ui.setStatus(BALANCE_KEY, undefined);
+		}
+	};
+
+	/**
+	 * Fetch the credit balance once and cache it. Fire-and-forget: failures
+	 * (no stored key, network errors, non-2xx, unexpected body) leave the
+	 * previous value untouched, and lastFetched was advanced at call time so
+	 * a broken endpoint is retried no more than once per BALANCE_REFRESH_MS.
+	 */
+	const fetchBalance = (ctx: ExtensionContext) => {
+		if (inflight) return;
+		lastFetched = Date.now();
+		inflight = (async () => {
+			try {
+				const auth = await ctx.modelRegistry?.getProviderAuth?.(DEEPSEEK_PROVIDER);
+				const apiKey = auth?.auth?.apiKey;
+				if (!apiKey) return;
+				// A custom baseUrl (proxy) is respected for the balance endpoint too;
+				// proxies that don't implement /user/balance just fail and keep the cache.
+				const origin = auth.auth.baseUrl ? new URL(auth.auth.baseUrl).origin : BALANCE_ORIGIN;
+				const res = await fetch(`${origin}/user/balance`, {
+					headers: { Authorization: `Bearer ${apiKey}` },
+				});
+				if (!res.ok) return;
+				const parsed = parseBalance(await res.json());
+				if (parsed) {
+					balance = formatBalance(parsed);
+					if (!parsed.isAvailable) balance.low = true; // credits exist but can't pay — flag it
+					applyBalance(ctx);
+				}
+			} catch {
+				// keep showing the cached value
+			} finally {
+				inflight = undefined;
+			}
+		})();
+	};
+
+	const update = async (ctx: ExtensionContext, model: ExtensionContext["model"]) => {
+		if (!isDeepSeekModel(model)) {
+			ctx.ui.setStatus(STATUS_KEY, undefined);
+			ctx.ui.setStatus(BALANCE_KEY, undefined);
+			return;
+		}
+		const { text, color } = statusText(new Date());
+		ctx.ui.setStatus(STATUS_KEY, ctx.ui.theme.fg(color, text));
+		applyBalance(ctx);
+		if (Date.now() - lastFetched >= BALANCE_REFRESH_MS) fetchBalance(ctx);
+	};
+
+	pi.on("session_start", async (_event, ctx) => {
+		if (timer) clearInterval(timer);
+		await update(ctx, ctx.model);
+		timer = setInterval(() => void update(ctx, ctx.model), REFRESH_MS);
+	});
+
+	// Balance can drop mid-session (usage debits, new grants) — re-check on the
+	// throttled schedule after each turn as well.
+	pi.on("turn_end", async (_event, ctx) => {
+		await update(ctx, ctx.model);
+	});
+
+	pi.on("model_select", async (event, ctx) => {
+		await update(ctx, ctx.model ?? event.model);
+	});
+
+	pi.on("session_shutdown", async () => {
+		if (timer) {
+			clearInterval(timer);
+			timer = undefined;
+		}
+	});
+}

package/package.json

@@ -0,0 +1,63 @@
+{
+	"name": "@khaosoigai/pi-ds-pricing-regime",
+	"version": "0.1.0",
+	"description": "Pi extension: shows DeepSeek peak/off-peak billing mode in the footer, timezone-aware",
+	"keywords": [
+		"pi",
+		"pi-package",
+		"pi-extension",
+		"deepseek",
+		"peak",
+		"off-peak",
+		"pricing"
+	],
+	"license": "MIT",
+	"pi": {
+		"extensions": [
+			"./extensions"
+		]
+	},
+	"author": {
+		"name": "khaosoigai",
+		"url": "https://github.com/khaosoi"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/khaosoi/pi-ds-pricing-regime.git"
+	},
+	"bugs": {
+		"url": "https://github.com/khaosoi/pi-ds-pricing-regime/issues"
+	},
+	"homepage": "https://github.com/khaosoi/pi-ds-pricing-regime#readme",
+	"type": "module",
+	"files": [
+		"extensions",
+		"LICENSE",
+		"README.md"
+	],
+	"engines": {
+		"node": ">=23"
+	},
+	"scripts": {
+		"format": "biome format extensions test scripts package.json tsconfig.json biome.json --write",
+		"format:check": "biome format extensions test scripts package.json tsconfig.json biome.json",
+		"lint": "biome lint extensions test scripts package.json tsconfig.json biome.json",
+		"check": "npm run format:check && npm run lint",
+		"typecheck": "tsc -p tsconfig.json",
+		"test": "node --test",
+		"coverage": "node --test --experimental-test-coverage",
+		"preview:package": "npm pack --dry-run",
+		"prepublishOnly": "npm run check && npm run typecheck && npm test"
+	},
+	"peerDependencies": {
+		"@earendil-works/pi-coding-agent": "*"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"devDependencies": {
+		"@biomejs/biome": "2.5.8",
+		"@types/node": "^22.10.0",
+		"typescript": "^5.7.0"
+	}
+}