@donebear/cli 0.1.0

package/dist/cli.mjs

@@ -0,0 +1,3676 @@
+#!/usr/bin/env node
+import { createRequire } from "node:module";
+import { Command } from "commander";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { createClient } from "@supabase/supabase-js";
+import { existsSync } from "node:fs";
+import { config } from "dotenv";
+import { execSync, spawn } from "node:child_process";
+import { randomBytes, randomUUID } from "node:crypto";
+import { createServer } from "node:http";
+import { styleText } from "node:util";
+import { createInterface } from "node:readline";
+
+//#region src/constants.ts
+const CLI_NAME = "donebear";
+const DONEBEAR_TOKEN_ENV = "DONEBEAR_TOKEN";
+const DONEBEAR_DEBUG_ENV = "DONEBEAR_DEBUG";
+const DONEBEAR_CONFIG_DIR_ENV = "DONEBEAR_CONFIG_DIR";
+const DONEBEAR_SUPABASE_URL_ENV = "DONEBEAR_SUPABASE_URL";
+const DONEBEAR_SUPABASE_KEY_ENV = "DONEBEAR_SUPABASE_PUBLISHABLE_KEY";
+const DONEBEAR_API_URL_ENV = "DONEBEAR_API_URL";
+const FALLBACK_SUPABASE_URL_ENV_KEYS = ["NEXT_PUBLIC_SUPABASE_URL", "SUPABASE_URL"];
+const FALLBACK_SUPABASE_KEY_ENV_KEYS = ["NEXT_PUBLIC_SUPABASE_PUBLISHABLE_OR_ANON_KEY", "SUPABASE_ANON_KEY"];
+const FALLBACK_API_URL_ENV_KEYS = ["NEXT_PUBLIC_RESERVE_MANAGE_API"];
+const DEFAULT_API_URL = "http://127.0.0.1:3001";
+const DEFAULT_OAUTH_PROVIDER = "google";
+const DEFAULT_OAUTH_CALLBACK_PORT = 8787;
+const DEFAULT_OAUTH_CALLBACK_PATH = "/auth/callback";
+const DEFAULT_OAUTH_TIMEOUT_SECONDS = 180;
+function getDefaultConfigBaseDir() {
+	if (process.platform === "win32") return process.env.APPDATA ?? join(homedir(), "AppData", "Roaming");
+	return process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config");
+}
+const configBaseDir = getDefaultConfigBaseDir();
+const CONFIG_DIR = process.env[DONEBEAR_CONFIG_DIR_ENV] ?? join(configBaseDir, CLI_NAME);
+const AUTH_FILE_PATH = join(CONFIG_DIR, "auth.json");
+const CONTEXT_FILE_PATH = join(CONFIG_DIR, "context.json");
+
+//#endregion
+//#region src/errors.ts
+const EXIT_CODES = {
+	SUCCESS: 0,
+	ERROR: 1,
+	CANCELLED: 2,
+	AUTH_REQUIRED: 4
+};
+var CliError = class extends Error {
+	exitCode;
+	constructor(message, exitCode = EXIT_CODES.ERROR) {
+		super(message);
+		this.name = "CliError";
+		this.exitCode = exitCode;
+	}
+};
+function toCliError(error) {
+	if (error instanceof CliError) return error;
+	if (error instanceof Error) return new CliError(error.message, EXIT_CODES.ERROR);
+	return new CliError("Unknown error", EXIT_CODES.ERROR);
+}
+
+//#endregion
+//#region src/storage.ts
+function isRecord$1(value) {
+	return typeof value === "object" && value !== null;
+}
+function isOAuthProvider(value) {
+	return value === "google" || value === "github";
+}
+function parseStoredAuthSession(value) {
+	if (!isRecord$1(value)) return null;
+	if (typeof value.accessToken !== "string") return null;
+	if (value.refreshToken !== null && typeof value.refreshToken !== "string") return null;
+	if (value.tokenType !== null && typeof value.tokenType !== "string") return null;
+	if (value.expiresAt !== null && typeof value.expiresAt !== "string") return null;
+	if (!isOAuthProvider(value.provider)) return null;
+	const user = value.user;
+	if (user !== null && (!isRecord$1(user) || typeof user.id !== "string" || user.email !== null && typeof user.email !== "string")) return null;
+	if (typeof value.createdAt !== "string") return null;
+	const parsedUser = user === null ? null : {
+		id: user.id,
+		email: user.email ?? null
+	};
+	return {
+		accessToken: value.accessToken,
+		refreshToken: value.refreshToken,
+		tokenType: value.tokenType,
+		expiresAt: value.expiresAt,
+		provider: value.provider,
+		user: parsedUser,
+		createdAt: value.createdAt
+	};
+}
+function parseAuthFile(payload) {
+	const parsed = JSON.parse(payload);
+	if (!isRecord$1(parsed) || parsed.version !== 1) throw new CliError(`Invalid auth cache format in ${AUTH_FILE_PATH}`, EXIT_CODES.ERROR);
+	const session = parseStoredAuthSession(parsed.session);
+	if (!session) throw new CliError(`Invalid auth session in ${AUTH_FILE_PATH}`, EXIT_CODES.ERROR);
+	return {
+		version: 1,
+		session
+	};
+}
+async function readStoredAuthSession() {
+	try {
+		return parseAuthFile(await readFile(AUTH_FILE_PATH, "utf8")).session;
+	} catch (error) {
+		if (isRecord$1(error) && error.code === "ENOENT") return null;
+		if (error instanceof CliError) throw error;
+		throw new CliError(`Failed to read credentials from ${AUTH_FILE_PATH}`, EXIT_CODES.ERROR);
+	}
+}
+async function writeStoredAuthSession(session) {
+	const payload = {
+		version: 1,
+		session
+	};
+	await mkdir(CONFIG_DIR, {
+		recursive: true,
+		mode: 448
+	});
+	await writeFile(AUTH_FILE_PATH, `${JSON.stringify(payload, null, 2)}\n`, {
+		encoding: "utf8",
+		mode: 384
+	});
+}
+async function clearStoredAuthSession() {
+	await rm(AUTH_FILE_PATH, { force: true });
+}
+
+//#endregion
+//#region src/env.ts
+const DEFAULT_ENV_FILES = [
+	".env.local",
+	".env",
+	"apps/manage-frontend/.env.local",
+	"apps/manage-api/.env"
+];
+let loaded = false;
+function loadCliEnvironmentFiles() {
+	if (loaded) return;
+	for (const relativePath of DEFAULT_ENV_FILES) {
+		const absolutePath = resolve(process.cwd(), relativePath);
+		if (!existsSync(absolutePath)) continue;
+		config({
+			path: absolutePath,
+			override: false,
+			quiet: true
+		});
+	}
+	loaded = true;
+}
+function readEnvValue(key) {
+	const value = process.env[key];
+	if (typeof value !== "string") return;
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : void 0;
+}
+
+//#endregion
+//#region src/supabase.ts
+var MemoryStorage = class {
+	values = /* @__PURE__ */ new Map();
+	getItem(key) {
+		return this.values.get(key) ?? null;
+	}
+	setItem(key, value) {
+		this.values.set(key, value);
+	}
+	removeItem(key) {
+		this.values.delete(key);
+	}
+};
+function firstDefined$1(keys) {
+	for (const key of keys) {
+		const value = readEnvValue(key);
+		if (value) return value;
+	}
+}
+function resolveSupabaseConfig() {
+	const url = readEnvValue(DONEBEAR_SUPABASE_URL_ENV) ?? firstDefined$1(FALLBACK_SUPABASE_URL_ENV_KEYS);
+	const publishableKey = readEnvValue(DONEBEAR_SUPABASE_KEY_ENV) ?? firstDefined$1(FALLBACK_SUPABASE_KEY_ENV_KEYS);
+	if (!(url && publishableKey)) throw new CliError([
+		"Supabase configuration is missing.",
+		`Set ${DONEBEAR_SUPABASE_URL_ENV} and ${DONEBEAR_SUPABASE_KEY_ENV}.`,
+		`Fallback keys are also supported: ${FALLBACK_SUPABASE_URL_ENV_KEYS.join(", ")} and ${FALLBACK_SUPABASE_KEY_ENV_KEYS.join(", ")}.`
+	].join(" "), EXIT_CODES.ERROR);
+	return {
+		url,
+		publishableKey
+	};
+}
+function createSupabaseClient(config, options) {
+	return createClient(config.url, config.publishableKey, { auth: {
+		flowType: "pkce",
+		autoRefreshToken: false,
+		detectSessionInUrl: false,
+		persistSession: options?.persistSession ?? false,
+		storage: options?.storage
+	} });
+}
+function createPkceSupabaseClient(config) {
+	return createSupabaseClient(config, {
+		storage: new MemoryStorage(),
+		persistSession: true
+	});
+}
+function toStoredAuthSession(session, provider) {
+	const expiresAt = typeof session.expires_at === "number" ? (/* @__PURE__ */ new Date(session.expires_at * 1e3)).toISOString() : null;
+	return {
+		accessToken: session.access_token,
+		refreshToken: session.refresh_token ?? null,
+		tokenType: session.token_type ?? null,
+		expiresAt,
+		provider,
+		user: session.user ? {
+			id: session.user.id,
+			email: session.user.email ?? null
+		} : null,
+		createdAt: (/* @__PURE__ */ new Date()).toISOString()
+	};
+}
+async function refreshSupabaseSession(config, refreshToken) {
+	const { data, error } = await createSupabaseClient(config).auth.refreshSession({ refresh_token: refreshToken });
+	if (error) throw new CliError(`Failed to refresh session: ${error.message}`, EXIT_CODES.AUTH_REQUIRED);
+	if (!data.session) throw new CliError("No session returned during refresh", EXIT_CODES.AUTH_REQUIRED);
+	return data.session;
+}
+async function getSupabaseUser(config, accessToken) {
+	const { data, error } = await createSupabaseClient(config).auth.getUser(accessToken);
+	if (error) throw new CliError(`Failed to load user: ${error.message}`, EXIT_CODES.ERROR);
+	if (!data.user) throw new CliError("No user returned for current token", EXIT_CODES.ERROR);
+	return data.user;
+}
+
+//#endregion
+//#region src/auth-session.ts
+function parseJwtBase64Url(input) {
+	const normalized = input.replace(/-/g, "+").replace(/_/g, "/");
+	const padded = normalized.padEnd(Math.ceil(normalized.length / 4) * 4, "=");
+	return Buffer.from(padded, "base64").toString("utf8");
+}
+function parseJwtClaims(token) {
+	const payloadPart = token.split(".").at(1);
+	if (!payloadPart) return null;
+	try {
+		const payload = parseJwtBase64Url(payloadPart);
+		const parsed = JSON.parse(payload);
+		if (typeof parsed !== "object" || parsed === null) return null;
+		const claims = parsed;
+		return {
+			exp: typeof claims.exp === "number" ? claims.exp : void 0,
+			email: typeof claims.email === "string" ? claims.email : void 0,
+			sub: typeof claims.sub === "string" ? claims.sub : void 0
+		};
+	} catch {
+		return null;
+	}
+}
+function expiryFromClaims(claims) {
+	if (!claims || typeof claims.exp !== "number") return null;
+	return (/* @__PURE__ */ new Date(claims.exp * 1e3)).toISOString();
+}
+function userFromClaims(claims) {
+	if (!(claims?.sub || claims?.email)) return null;
+	return {
+		id: claims.sub ?? "unknown",
+		email: claims.email ?? null
+	};
+}
+function nowUnixSeconds() {
+	return Math.floor(Date.now() / 1e3);
+}
+function isExpired(session) {
+	if (!session.expiresAt) return false;
+	const expiresAtMs = Date.parse(session.expiresAt);
+	if (Number.isNaN(expiresAtMs)) return false;
+	return expiresAtMs <= Date.now();
+}
+function shouldRefresh(session) {
+	if (!session.expiresAt) return false;
+	const expiresAtMs = Date.parse(session.expiresAt);
+	if (Number.isNaN(expiresAtMs)) return false;
+	return expiresAtMs - Date.now() <= 6e4;
+}
+function tokenFromRaw(token, source) {
+	const claims = parseJwtClaims(token);
+	return {
+		token,
+		source,
+		expiresAt: expiryFromClaims(claims),
+		user: userFromClaims(claims)
+	};
+}
+async function resolveAuthToken(context, config) {
+	if (context.tokenOverride) return tokenFromRaw(context.tokenOverride, "flag");
+	const envToken = process.env[DONEBEAR_TOKEN_ENV]?.trim();
+	if (envToken) return tokenFromRaw(envToken, "environment");
+	const session = await readStoredAuthSession();
+	if (!session) return null;
+	if (!(shouldRefresh(session) || isExpired(session))) return {
+		token: session.accessToken,
+		source: "stored",
+		expiresAt: session.expiresAt,
+		user: session.user
+	};
+	if (!(session.refreshToken && config)) {
+		if (isExpired(session)) {
+			await clearStoredAuthSession();
+			return null;
+		}
+		return {
+			token: session.accessToken,
+			source: "stored",
+			expiresAt: session.expiresAt,
+			user: session.user
+		};
+	}
+	const updatedSession = toStoredAuthSession(await refreshSupabaseSession(config, session.refreshToken), session.provider);
+	await writeStoredAuthSession(updatedSession);
+	return {
+		token: updatedSession.accessToken,
+		source: "stored",
+		expiresAt: updatedSession.expiresAt,
+		user: updatedSession.user
+	};
+}
+function resolveTokenStatus(token) {
+	const claims = parseJwtClaims(token.token);
+	if (!claims?.exp) return {
+		expiresInSeconds: null,
+		expired: false
+	};
+	const expiresInSeconds = claims.exp - nowUnixSeconds();
+	return {
+		expiresInSeconds,
+		expired: expiresInSeconds <= 0
+	};
+}
+
+//#endregion
+//#region src/browser.ts
+function getOpenCommand(url) {
+	if (process.platform === "darwin") return {
+		command: "open",
+		args: [url]
+	};
+	if (process.platform === "win32") return {
+		command: "cmd",
+		args: [
+			"/c",
+			"start",
+			"",
+			url
+		]
+	};
+	return {
+		command: "xdg-open",
+		args: [url]
+	};
+}
+async function openUrl(url) {
+	const openCommand = getOpenCommand(url);
+	return await new Promise((resolve) => {
+		try {
+			const child = spawn(openCommand.command, openCommand.args, {
+				detached: true,
+				stdio: "ignore"
+			});
+			child.once("error", () => {
+				resolve(false);
+			});
+			child.once("spawn", () => {
+				child.unref();
+				resolve(true);
+			});
+		} catch {
+			resolve(false);
+		}
+	});
+}
+
+//#endregion
+//#region src/command-parsers.ts
+function parsePositiveInteger(value, label) {
+	const parsed = Number.parseInt(value, 10);
+	if (!Number.isInteger(parsed) || parsed <= 0) throw new Error(`${label} must be a positive integer`);
+	return parsed;
+}
+
+//#endregion
+//#region src/oauth.ts
+function createOAuthState() {
+	return randomBytes(24).toString("hex");
+}
+
+//#endregion
+//#region src/oauth-callback.ts
+function successHtml() {
+	return `<!doctype html><html><head><meta charset="utf-8"/><title>Done Bear CLI</title></head><body><h1>Authentication complete</h1><p>You can return to your terminal.</p></body></html>`;
+}
+function errorHtml(message) {
+	return `<!doctype html><html><head><meta charset="utf-8"/><title>Done Bear CLI</title></head><body><h1>Authentication failed</h1><p>${message}</p></body></html>`;
+}
+async function waitForOAuthCode(options) {
+	return await new Promise((resolve, reject) => {
+		const host = options.redirectUrl.hostname;
+		const port = Number(options.redirectUrl.port);
+		const pathname = options.redirectUrl.pathname;
+		if (!Number.isInteger(port) || port <= 0) {
+			reject(new CliError("OAuth redirect URL requires an explicit port", EXIT_CODES.ERROR));
+			return;
+		}
+		let settled = false;
+		const finish = (result) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timeout);
+			server.close(() => {
+				if (result.error) {
+					reject(result.error);
+					return;
+				}
+				resolve(result.code ?? "");
+			});
+		};
+		const server = createServer((request, response) => {
+			if (!request.url) {
+				response.writeHead(400, { "content-type": "text/html; charset=utf-8" });
+				response.end(errorHtml("Missing request URL"));
+				finish({ error: new CliError("OAuth callback is missing a request URL", EXIT_CODES.ERROR) });
+				return;
+			}
+			const url = new URL(request.url, options.redirectUrl.origin);
+			if (url.pathname !== pathname) {
+				response.writeHead(404, { "content-type": "text/html; charset=utf-8" });
+				response.end(errorHtml("Invalid callback path"));
+				return;
+			}
+			const providerError = url.searchParams.get("error");
+			if (providerError) {
+				const description = url.searchParams.get("error_description") ?? providerError;
+				response.writeHead(400, { "content-type": "text/html; charset=utf-8" });
+				response.end(errorHtml(description));
+				finish({ error: new CliError(`OAuth provider returned an error: ${description}`, EXIT_CODES.ERROR) });
+				return;
+			}
+			if (url.searchParams.get("state") !== options.expectedState) {
+				response.writeHead(400, { "content-type": "text/html; charset=utf-8" });
+				response.end(errorHtml("State verification failed"));
+				finish({ error: new CliError("OAuth state verification failed", EXIT_CODES.ERROR) });
+				return;
+			}
+			const code = url.searchParams.get("code");
+			if (!code) {
+				response.writeHead(400, { "content-type": "text/html; charset=utf-8" });
+				response.end(errorHtml("Authorization code was missing"));
+				finish({ error: new CliError("OAuth callback is missing an authorization code", EXIT_CODES.ERROR) });
+				return;
+			}
+			response.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+			response.end(successHtml());
+			finish({ code });
+		});
+		server.on("error", (error) => {
+			finish({ error: new CliError(`Failed to start callback server on ${host}:${port}: ${error.message}`, EXIT_CODES.ERROR) });
+		});
+		const timeout = setTimeout(() => {
+			finish({ error: new CliError("Timed out waiting for OAuth callback", EXIT_CODES.CANCELLED) });
+		}, options.timeoutMs);
+		server.listen(port, host);
+	});
+}
+
+//#endregion
+//#region src/output.ts
+function writeLine(stream, message) {
+	stream.write(`${message}\n`);
+}
+function colorize(context, format, message) {
+	if (!context.color) return message;
+	return styleText(format, message);
+}
+function writeJson(value) {
+	writeLine(process.stdout, JSON.stringify(value, null, 2));
+}
+function writeInfo(context, message) {
+	writeLine(process.stdout, colorize(context, "cyan", message));
+}
+function writeSuccess(context, message) {
+	writeLine(process.stdout, colorize(context, "green", message));
+}
+function writeWarning(context, message) {
+	writeLine(process.stderr, colorize(context, "yellow", message));
+}
+function writeError(context, message) {
+	writeLine(process.stderr, colorize(context, "red", message));
+}
+function writeDebug(context, message) {
+	if (!context.debug) return;
+	writeLine(process.stderr, colorize(context, "gray", `[debug] ${message}`));
+}
+function writeTotal(context, count) {
+	writeLine(process.stdout, colorize(context, "cyan", String(count)));
+}
+function escapeCsvField(value) {
+	if (value.includes(",") || value.includes("\"") || value.includes("\n")) return `"${value.replace(/"/g, "\"\"")}"`;
+	return value;
+}
+function writeCsv(headers, rows) {
+	writeLine(process.stdout, headers.map(escapeCsvField).join(","));
+	for (const row of rows) writeLine(process.stdout, row.map(escapeCsvField).join(","));
+}
+function writeTsv(headers, rows) {
+	writeLine(process.stdout, headers.join("	"));
+	for (const row of rows) writeLine(process.stdout, row.join("	"));
+}
+/**
+* Handles --total, --format csv, --format tsv output (including --copy for tabular data).
+* Returns true if the format was handled; caller renders text mode if false.
+*/
+function writeFormattedRows(context, totalCount, headers, rows) {
+	if (context.total) {
+		writeTotal(context, totalCount);
+		return true;
+	}
+	if (context.format === "csv") {
+		writeCsv(headers, rows);
+		if (context.copy) copyToClipboard([headers.join(","), ...rows.map((r) => r.join(","))].join("\n"));
+		return true;
+	}
+	if (context.format === "tsv") {
+		writeTsv(headers, rows);
+		if (context.copy) copyToClipboard([headers.join("	"), ...rows.map((r) => r.join("	"))].join("\n"));
+		return true;
+	}
+	return false;
+}
+function copyToClipboard(text) {
+	try {
+		if (process.platform === "darwin") execSync("pbcopy", { input: text });
+		else if (process.platform === "win32") execSync("clip", { input: text });
+		else try {
+			execSync("xclip -selection clipboard", { input: text });
+		} catch {
+			execSync("xsel --clipboard --input", { input: text });
+		}
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+//#endregion
+//#region src/runtime.ts
+function parseOutputFormat(value) {
+	switch (value?.trim().toLowerCase()) {
+		case "json": return "json";
+		case "csv": return "csv";
+		case "tsv": return "tsv";
+		default: return "text";
+	}
+}
+function contextFromCommand(command) {
+	const options = command.optsWithGlobals();
+	const rawFormat = parseOutputFormat(options.format);
+	const format = options.json === true ? "json" : rawFormat;
+	return {
+		json: format === "json",
+		color: options.color !== false && process.env.NO_COLOR !== "1",
+		debug: options.debug === true || process.env[DONEBEAR_DEBUG_ENV] === "1",
+		tokenOverride: options.token?.trim() || null,
+		apiUrlOverride: options.apiUrl?.trim() || null,
+		format,
+		copy: options.copy === true,
+		total: options.total === true
+	};
+}
+function contextFromArgv(argv) {
+	const hasJsonFlag = argv.includes("--json");
+	const rawFormat = argv.some((a) => a === "--format=json" || argv[argv.indexOf("--format") + 1] === "json" && a === "--format") ? "json" : "text";
+	const format = hasJsonFlag ? "json" : rawFormat;
+	return {
+		json: format === "json",
+		color: !argv.includes("--no-color") && process.env.NO_COLOR !== "1",
+		debug: argv.includes("--debug") || process.env[DONEBEAR_DEBUG_ENV] === "1",
+		tokenOverride: null,
+		apiUrlOverride: null,
+		format,
+		copy: argv.includes("--copy"),
+		total: argv.includes("--total")
+	};
+}
+async function runWithErrorHandling(context, action) {
+	try {
+		await action();
+	} catch (error) {
+		const cliError = toCliError(error);
+		if (context.json) writeJson({
+			ok: false,
+			error: {
+				message: cliError.message,
+				exitCode: cliError.exitCode
+			}
+		});
+		else writeError(context, cliError.message);
+		if (context.debug && error instanceof Error && typeof error.stack === "string") writeDebug(context, error.stack);
+		process.exitCode = cliError.exitCode;
+	}
+}
+
+//#endregion
+//#region src/commands/auth.ts
+const SUPPORTED_PROVIDERS = ["google", "github"];
+function parseProvider(value) {
+	const normalized = value.trim().toLowerCase();
+	if (SUPPORTED_PROVIDERS.some((provider) => provider === normalized)) return normalized;
+	throw new Error(`Unsupported provider "${value}". Supported providers: ${SUPPORTED_PROVIDERS.join(", ")}.`);
+}
+async function runLogin(context, options) {
+	const provider = parseProvider(options.provider);
+	const config = resolveSupabaseConfig();
+	const redirectUrl = new URL(`http://127.0.0.1:${options.port}${DEFAULT_OAUTH_CALLBACK_PATH}`);
+	const state = createOAuthState();
+	const client = createPkceSupabaseClient(config);
+	const { data: oauthStart, error: oauthStartError } = await client.auth.signInWithOAuth({
+		provider,
+		options: {
+			redirectTo: redirectUrl.toString(),
+			queryParams: { state },
+			skipBrowserRedirect: true
+		}
+	});
+	if (oauthStartError) throw new Error(`Failed to start OAuth flow: ${oauthStartError.message}`);
+	if (!oauthStart.url) throw new Error("Supabase did not return an OAuth URL");
+	const callbackPromise = waitForOAuthCode({
+		redirectUrl,
+		expectedState: state,
+		timeoutMs: options.timeout * 1e3
+	});
+	if (!options.open) {
+		writeInfo(context, "Open this URL to continue authentication:");
+		writeInfo(context, oauthStart.url);
+	} else if (await openUrl(oauthStart.url)) writeInfo(context, "Opened browser for authentication.");
+	else {
+		writeWarning(context, "Failed to open the browser automatically. Open this URL manually:");
+		writeInfo(context, oauthStart.url);
+	}
+	const authorizationCode = await callbackPromise;
+	const { data: sessionData, error: exchangeError } = await client.auth.exchangeCodeForSession(authorizationCode);
+	if (exchangeError) throw new Error(`OAuth callback exchange failed: ${exchangeError.message}`);
+	if (!sessionData.session) throw new Error("OAuth callback did not return a session");
+	const storedSession = toStoredAuthSession(sessionData.session, provider);
+	await writeStoredAuthSession(storedSession);
+	if (context.json) {
+		writeJson({
+			ok: true,
+			provider,
+			user: storedSession.user,
+			expiresAt: storedSession.expiresAt,
+			source: "stored"
+		});
+		return;
+	}
+	writeSuccess(context, "Authentication succeeded.");
+	if (storedSession.user?.email) writeInfo(context, `Signed in as ${storedSession.user.email}`);
+}
+async function runStatus(context) {
+	const token = await resolveAuthToken(context, getOptionalSupabaseConfig$1());
+	if (!token) {
+		if (context.json) writeJson({
+			authenticated: false,
+			source: null
+		});
+		else {
+			writeInfo(context, "Not authenticated.");
+			writeInfo(context, "Run `donebear auth login` to authenticate.");
+		}
+		process.exitCode = EXIT_CODES.AUTH_REQUIRED;
+		return;
+	}
+	const tokenStatus = resolveTokenStatus(token);
+	if (context.json) {
+		writeJson({
+			authenticated: true,
+			source: token.source,
+			user: token.user,
+			expiresAt: token.expiresAt,
+			expiresInSeconds: tokenStatus.expiresInSeconds,
+			expired: tokenStatus.expired
+		});
+		return;
+	}
+	writeSuccess(context, "Authenticated.");
+	writeInfo(context, `Source: ${token.source}`);
+	if (token.user?.email) writeInfo(context, `User: ${token.user.email}`);
+	if (token.expiresAt) writeInfo(context, `Expires at: ${token.expiresAt}`);
+}
+async function runLogout(context) {
+	const existingSession = await readStoredAuthSession();
+	await clearStoredAuthSession();
+	if (context.json) {
+		writeJson({
+			ok: true,
+			removedStoredCredentials: existingSession !== null
+		});
+		return;
+	}
+	if (existingSession) writeSuccess(context, "Stored credentials removed.");
+	else writeInfo(context, "No stored credentials found.");
+}
+function getOptionalSupabaseConfig$1() {
+	try {
+		return resolveSupabaseConfig();
+	} catch {
+		return null;
+	}
+}
+function registerAuthCommands(program) {
+	const auth = program.command("auth").description("Authenticate donebear CLI").addHelpText("after", `
+Examples:
+  donebear auth
+  donebear auth login --provider github
+  donebear auth status --json
+  donebear auth logout
+`).action(async (_options, command) => {
+		const context = contextFromCommand(command);
+		await runWithErrorHandling(context, async () => {
+			await runStatus(context);
+		});
+	});
+	auth.command("login").description("Authenticate with OAuth in the browser").option("-p, --provider <provider>", `OAuth provider (${SUPPORTED_PROVIDERS.join("|")})`, DEFAULT_OAUTH_PROVIDER).option("--port <port>", "Loopback callback port", (value) => parsePositiveInteger(value, "Port"), DEFAULT_OAUTH_CALLBACK_PORT).option("--timeout <seconds>", "OAuth timeout in seconds", (value) => parsePositiveInteger(value, "Timeout"), DEFAULT_OAUTH_TIMEOUT_SECONDS).option("--no-open", "Print URL instead of opening the browser").action(async (options, command) => {
+		const context = contextFromCommand(command);
+		await runWithErrorHandling(context, async () => {
+			await runLogin(context, options);
+		});
+	});
+	auth.command("status").description("Check authentication status").action(async (_options, command) => {
+		const context = contextFromCommand(command);
+		await runWithErrorHandling(context, async () => {
+			await runStatus(context);
+		});
+	});
+	auth.command("logout").alias("clear").description("Remove local cached credentials").action(async (_options, command) => {
+		const context = contextFromCommand(command);
+		await runWithErrorHandling(context, async () => {
+			await runLogout(context);
+		});
+	});
+}
+
+//#endregion
+//#region src/context-store.ts
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+function parseLocalContext(value) {
+	if (!isRecord(value)) return null;
+	if (value.workspaceId !== null && typeof value.workspaceId !== "string") return null;
+	if (typeof value.clientId !== "string" || value.clientId.length === 0) return null;
+	return {
+		workspaceId: value.workspaceId,
+		clientId: value.clientId
+	};
+}
+function parseContextFile(payload) {
+	const parsed = JSON.parse(payload);
+	if (!isRecord(parsed) || parsed.version !== 1) throw new CliError(`Invalid CLI context format in ${CONTEXT_FILE_PATH}`, EXIT_CODES.ERROR);
+	const context = parseLocalContext(parsed.context);
+	if (!context) throw new CliError(`Invalid CLI context in ${CONTEXT_FILE_PATH}`, EXIT_CODES.ERROR);
+	return {
+		version: 1,
+		context
+	};
+}
+async function writeContext(context) {
+	const payload = {
+		version: 1,
+		context
+	};
+	await mkdir(CONFIG_DIR, {
+		recursive: true,
+		mode: 448
+	});
+	await writeFile(CONTEXT_FILE_PATH, `${JSON.stringify(payload, null, 2)}\n`, {
+		encoding: "utf8",
+		mode: 384
+	});
+}
+async function readLocalContext() {
+	try {
+		return parseContextFile(await readFile(CONTEXT_FILE_PATH, "utf8")).context;
+	} catch (error) {
+		if (isRecord(error) && error.code === "ENOENT") return null;
+		if (error instanceof CliError) throw error;
+		throw new CliError(`Failed to read context from ${CONTEXT_FILE_PATH}`, EXIT_CODES.ERROR);
+	}
+}
+async function ensureLocalContext() {
+	const existing = await readLocalContext();
+	if (existing) return existing;
+	const created = {
+		workspaceId: null,
+		clientId: randomUUID()
+	};
+	await writeContext(created);
+	return created;
+}
+async function setCurrentWorkspace(workspaceId) {
+	const nextContext = {
+		...await ensureLocalContext(),
+		workspaceId
+	};
+	await writeContext(nextContext);
+	return nextContext;
+}
+
+//#endregion
+//#region src/manage-api.ts
+const TASKS_QUERY = `
+  query DonebearTasks($first: Int!, $after: String, $workspaceId: ID!) {
+    tasks(first: $first, after: $after, filter: { workspaceId: { eq: $workspaceId } }) {
+      nodes {
+        id
+        title
+        description
+        createdAt
+        updatedAt
+        completedAt
+        archivedAt
+        start
+        startDate
+        startBucket
+        todayIndexReferenceDate
+        deadlineAt
+        creatorId
+        workspaceId
+        projectId
+        teamId
+        assigneeId
+        headingId
+      }
+      pageInfo {
+        hasNextPage
+        endCursor
+      }
+    }
+  }
+`;
+const PROJECTS_QUERY = `
+  query DonebearProjects($first: Int!, $after: String, $workspaceId: ID!) {
+    projects(first: $first, after: $after, filter: { workspaceId: { eq: $workspaceId } }) {
+      nodes {
+        id
+        key
+        name
+        description
+        status
+        sortOrder
+        targetDate
+        completedAt
+        archivedAt
+        createdAt
+        updatedAt
+        workspaceId
+        creatorId
+      }
+      pageInfo {
+        hasNextPage
+        endCursor
+      }
+    }
+  }
+`;
+const LABELS_QUERY = `
+  query DonebearLabels($first: Int!, $after: String, $workspaceId: ID!) {
+    labels(first: $first, after: $after, filter: { workspaceId: { eq: $workspaceId } }) {
+      nodes {
+        id
+        title
+        workspaceId
+        createdAt
+        updatedAt
+      }
+      pageInfo {
+        hasNextPage
+        endCursor
+      }
+    }
+  }
+`;
+const TEAMS_QUERY = `
+  query DonebearTeams($first: Int!, $after: String, $workspaceId: ID!) {
+    teams(first: $first, after: $after, filter: { workspaceId: { eq: $workspaceId } }) {
+      nodes {
+        id
+        key
+        name
+        description
+        workspaceId
+        createdAt
+        updatedAt
+        archivedAt
+      }
+      pageInfo {
+        hasNextPage
+        endCursor
+      }
+    }
+  }
+`;
+function normalizeApiUrl(url) {
+	return url.endsWith("/") ? url.slice(0, -1) : url;
+}
+function firstDefined(keys) {
+	for (const key of keys) {
+		const value = readEnvValue(key);
+		if (value) return value;
+	}
+}
+function extractErrorMessage(value) {
+	if (typeof value === "string") return value;
+	if (typeof value !== "object" || value === null) return "Request failed";
+	const record = value;
+	if (typeof record.message === "string") return record.message;
+	if (typeof record.error === "string") return record.error;
+	return "Request failed";
+}
+async function request(_context, endpoint, options) {
+	const headers = new Headers({
+		Authorization: `Bearer ${options.token}`,
+		Accept: "application/json"
+	});
+	if (options.body !== void 0) headers.set("Content-Type", "application/json");
+	const response = await fetch(endpoint, {
+		method: options.method ?? "GET",
+		headers,
+		body: options.body === void 0 ? void 0 : JSON.stringify(options.body)
+	});
+	if (response.ok) return response;
+	const raw = await response.text();
+	let parsed = null;
+	try {
+		parsed = raw.length > 0 ? JSON.parse(raw) : null;
+	} catch {
+		parsed = null;
+	}
+	let message = `HTTP ${response.status}`;
+	if (parsed !== null) message = extractErrorMessage(parsed);
+	else if (raw.length > 0) message = raw;
+	const exitCode = response.status === 401 || response.status === 403 ? EXIT_CODES.AUTH_REQUIRED : EXIT_CODES.ERROR;
+	throw new CliError(message, exitCode);
+}
+async function requestJson(context, endpoint, options) {
+	return await (await request(context, endpoint, options)).json();
+}
+async function requestNdjson(context, endpoint, options) {
+	const lines = (await (await request(context, endpoint, {
+		method: "POST",
+		token: options.token,
+		body: options.body
+	})).text()).split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+	const parsed = [];
+	for (const line of lines) parsed.push(JSON.parse(line));
+	return parsed;
+}
+async function requestGraphql(context, endpoint, options) {
+	const response = await requestJson(context, endpoint, {
+		method: "POST",
+		token: options.token,
+		body: {
+			query: options.query,
+			variables: options.variables
+		}
+	});
+	if (Array.isArray(response.errors) && response.errors.length > 0) {
+		const first = response.errors[0];
+		throw new CliError(typeof first?.message === "string" ? first.message : "GraphQL request failed", EXIT_CODES.ERROR);
+	}
+	if (!response.data) throw new CliError("GraphQL request returned no data", EXIT_CODES.ERROR);
+	return response.data;
+}
+function toTaskRecord(value) {
+	if (typeof value !== "object" || value === null) return null;
+	const row = value;
+	if (row.__class !== "Task") return null;
+	if (typeof row.id !== "string" || typeof row.title !== "string") return null;
+	if (typeof row.creatorId !== "string" || typeof row.workspaceId !== "string" || typeof row.start !== "string" || typeof row.startBucket !== "string") return null;
+	return {
+		id: row.id,
+		title: row.title,
+		description: typeof row.description === "string" ? row.description : null,
+		createdAt: toNullableNumber(row.createdAt),
+		updatedAt: toNullableNumber(row.updatedAt),
+		completedAt: toNullableNumber(row.completedAt),
+		archivedAt: toNullableNumber(row.archivedAt),
+		start: row.start,
+		startDate: toNullableNumber(row.startDate),
+		startBucket: row.startBucket,
+		todayIndexReferenceDate: toNullableNumber(row.todayIndexReferenceDate),
+		deadlineAt: toNullableNumber(row.deadlineAt),
+		creatorId: row.creatorId,
+		workspaceId: row.workspaceId,
+		projectId: typeof row.projectId === "string" ? row.projectId : null,
+		teamId: typeof row.teamId === "string" ? row.teamId : null,
+		assigneeId: typeof row.assigneeId === "string" ? row.assigneeId : null,
+		headingId: typeof row.headingId === "string" ? row.headingId : null
+	};
+}
+function toNullableNumber(input) {
+	if (input === null || typeof input === "undefined") return null;
+	return typeof input === "number" ? input : null;
+}
+function parseIsoDateToEpoch(value) {
+	if (typeof value !== "string") return null;
+	const parsed = Date.parse(value);
+	return Number.isNaN(parsed) ? null : parsed;
+}
+function toTaskRecordFromGraphqlNode(node) {
+	return {
+		id: node.id,
+		title: node.title,
+		description: node.description,
+		createdAt: parseIsoDateToEpoch(node.createdAt),
+		updatedAt: parseIsoDateToEpoch(node.updatedAt),
+		completedAt: parseIsoDateToEpoch(node.completedAt),
+		archivedAt: parseIsoDateToEpoch(node.archivedAt),
+		start: node.start,
+		startDate: parseIsoDateToEpoch(node.startDate),
+		startBucket: node.startBucket,
+		todayIndexReferenceDate: parseIsoDateToEpoch(node.todayIndexReferenceDate),
+		deadlineAt: parseIsoDateToEpoch(node.deadlineAt),
+		creatorId: node.creatorId,
+		workspaceId: node.workspaceId,
+		projectId: node.projectId,
+		teamId: node.teamId,
+		assigneeId: node.assigneeId,
+		headingId: node.headingId
+	};
+}
+function toProjectRecordFromGraphqlNode(node) {
+	return {
+		id: node.id,
+		key: node.key,
+		name: node.name,
+		description: node.description,
+		status: node.status,
+		sortOrder: node.sortOrder,
+		targetDate: parseIsoDateToEpoch(node.targetDate),
+		completedAt: parseIsoDateToEpoch(node.completedAt),
+		archivedAt: parseIsoDateToEpoch(node.archivedAt),
+		createdAt: parseIsoDateToEpoch(node.createdAt),
+		updatedAt: parseIsoDateToEpoch(node.updatedAt),
+		workspaceId: node.workspaceId,
+		creatorId: node.creatorId
+	};
+}
+function toLabelRecordFromGraphqlNode(node) {
+	return {
+		id: node.id,
+		title: node.title,
+		workspaceId: node.workspaceId,
+		createdAt: parseIsoDateToEpoch(node.createdAt),
+		updatedAt: parseIsoDateToEpoch(node.updatedAt)
+	};
+}
+function toTeamRecordFromGraphqlNode(node) {
+	return {
+		id: node.id,
+		key: node.key,
+		name: node.name,
+		description: node.description,
+		workspaceId: node.workspaceId,
+		createdAt: parseIsoDateToEpoch(node.createdAt),
+		updatedAt: parseIsoDateToEpoch(node.updatedAt),
+		archivedAt: parseIsoDateToEpoch(node.archivedAt)
+	};
+}
+function toChecklistItemRecord(value) {
+	if (typeof value !== "object" || value === null) return null;
+	const row = value;
+	if (row.__class !== "TaskChecklistItem") return null;
+	if (typeof row.id !== "string" || typeof row.title !== "string") return null;
+	if (typeof row.taskId !== "string" || typeof row.workspaceId !== "string") return null;
+	return {
+		id: row.id,
+		title: row.title,
+		taskId: row.taskId,
+		workspaceId: row.workspaceId,
+		sortOrder: typeof row.sortOrder === "number" ? row.sortOrder : 0,
+		completedAt: toNullableNumber(row.completedAt),
+		createdAt: toNullableNumber(row.createdAt),
+		updatedAt: toNullableNumber(row.updatedAt)
+	};
+}
+function resolveApiBaseUrl(context) {
+	const fromContext = context.apiUrlOverride?.trim();
+	if (fromContext) return normalizeApiUrl(fromContext);
+	return normalizeApiUrl(readEnvValue(DONEBEAR_API_URL_ENV) ?? firstDefined(FALLBACK_API_URL_ENV_KEYS) ?? DEFAULT_API_URL);
+}
+async function listWorkspaces(context, options) {
+	return (await requestJson(context, `${options.baseUrl}/api/workspaces`, { token: options.token })).workspaces;
+}
+async function createWorkspace(context, options) {
+	return (await requestJson(context, `${options.baseUrl}/api/workspaces`, {
+		method: "POST",
+		token: options.token,
+		body: options.body
+	})).workspace;
+}
+function joinWorkspace(context, options) {
+	return requestJson(context, `${options.baseUrl}/api/workspaces/join`, {
+		method: "POST",
+		token: options.token,
+		body: { code: options.code }
+	});
+}
+async function loadTasksByWorkspace(context, options) {
+	const endpoint = `${options.baseUrl}/graphql`;
+	const results = [];
+	let after = null;
+	let pageCount = 0;
+	while (true) {
+		pageCount += 1;
+		if (pageCount > 1e3) throw new CliError("GraphQL pagination exceeded safe page limit", EXIT_CODES.ERROR);
+		const data = await requestGraphql(context, endpoint, {
+			token: options.token,
+			query: TASKS_QUERY,
+			variables: {
+				first: 100,
+				after,
+				workspaceId: options.workspaceId
+			}
+		});
+		for (const node of data.tasks.nodes) results.push(toTaskRecordFromGraphqlNode(node));
+		const nextCursor = data.tasks.pageInfo.hasNextPage ? data.tasks.pageInfo.endCursor : null;
+		if (!nextCursor) break;
+		after = nextCursor;
+	}
+	return results;
+}
+async function loadTaskById(context, options) {
+	const url = `${options.baseUrl}/sync/batch`;
+	const body = { requests: [{
+		modelName: "Task",
+		indexedKey: "id",
+		keyValue: options.taskId
+	}] };
+	const rows = await requestNdjson(context, url, {
+		token: options.token,
+		body
+	});
+	for (const row of rows) {
+		const task = toTaskRecord(row);
+		if (task) return task;
+	}
+	return null;
+}
+async function mutateTask(context, options) {
+	const response = await requestJson(context, `${options.baseUrl}/sync/mutate`, {
+		method: "POST",
+		token: options.token,
+		body: options.request
+	});
+	if (!response.success) {
+		const error = response.results.find((result) => !result.success);
+		if (error?.error) throw new CliError(error.error, EXIT_CODES.ERROR);
+		throw new CliError("Sync mutation failed", EXIT_CODES.ERROR);
+	}
+}
+async function loadProjectsByWorkspace(context, options) {
+	const endpoint = `${options.baseUrl}/graphql`;
+	const results = [];
+	let after = null;
+	let pageCount = 0;
+	while (true) {
+		pageCount += 1;
+		if (pageCount > 1e3) throw new CliError("GraphQL pagination exceeded safe page limit", EXIT_CODES.ERROR);
+		const data = await requestGraphql(context, endpoint, {
+			token: options.token,
+			query: PROJECTS_QUERY,
+			variables: {
+				first: 100,
+				after,
+				workspaceId: options.workspaceId
+			}
+		});
+		for (const node of data.projects.nodes) results.push(toProjectRecordFromGraphqlNode(node));
+		const nextCursor = data.projects.pageInfo.hasNextPage ? data.projects.pageInfo.endCursor : null;
+		if (!nextCursor) break;
+		after = nextCursor;
+	}
+	return results;
+}
+async function loadLabelsByWorkspace(context, options) {
+	const endpoint = `${options.baseUrl}/graphql`;
+	const results = [];
+	let after = null;
+	let pageCount = 0;
+	while (true) {
+		pageCount += 1;
+		if (pageCount > 1e3) throw new CliError("GraphQL pagination exceeded safe page limit", EXIT_CODES.ERROR);
+		const data = await requestGraphql(context, endpoint, {
+			token: options.token,
+			query: LABELS_QUERY,
+			variables: {
+				first: 100,
+				after,
+				workspaceId: options.workspaceId
+			}
+		});
+		for (const node of data.labels.nodes) results.push(toLabelRecordFromGraphqlNode(node));
+		const nextCursor = data.labels.pageInfo.hasNextPage ? data.labels.pageInfo.endCursor : null;
+		if (!nextCursor) break;
+		after = nextCursor;
+	}
+	return results;
+}
+async function loadTeamsByWorkspace(context, options) {
+	const endpoint = `${options.baseUrl}/graphql`;
+	const results = [];
+	let after = null;
+	let pageCount = 0;
+	while (true) {
+		pageCount += 1;
+		if (pageCount > 1e3) throw new CliError("GraphQL pagination exceeded safe page limit", EXIT_CODES.ERROR);
+		const data = await requestGraphql(context, endpoint, {
+			token: options.token,
+			query: TEAMS_QUERY,
+			variables: {
+				first: 100,
+				after,
+				workspaceId: options.workspaceId
+			}
+		});
+		for (const node of data.teams.nodes) results.push(toTeamRecordFromGraphqlNode(node));
+		const nextCursor = data.teams.pageInfo.hasNextPage ? data.teams.pageInfo.endCursor : null;
+		if (!nextCursor) break;
+		after = nextCursor;
+	}
+	return results;
+}
+async function loadChecklistItemsByTask(context, options) {
+	const url = `${options.baseUrl}/sync/batch`;
+	const body = { requests: [{
+		modelName: "TaskChecklistItem",
+		indexedKey: "taskId",
+		keyValue: options.taskId
+	}] };
+	const rows = await requestNdjson(context, url, {
+		token: options.token,
+		body
+	});
+	const results = [];
+	for (const row of rows) {
+		const item = toChecklistItemRecord(row);
+		if (item) results.push(item);
+	}
+	return results;
+}
+async function mutateModel(context, options) {
+	const response = await requestJson(context, `${options.baseUrl}/sync/mutate`, {
+		method: "POST",
+		token: options.token,
+		body: options.request
+	});
+	if (!response.success) {
+		const error = response.results.find((result) => !result.success);
+		if (error?.error) throw new CliError(error.error, EXIT_CODES.ERROR);
+		throw new CliError("Sync mutation failed", EXIT_CODES.ERROR);
+	}
+}
+async function listWorkspaceMembers(context, options) {
+	const data = await requestJson(context, `${options.baseUrl}/api/workspaces/${options.workspaceId}/members`, { token: options.token });
+	return Array.isArray(data) ? data : data.members ?? [];
+}
+async function listWorkspaceInvitations(context, options) {
+	const data = await requestJson(context, `${options.baseUrl}/api/workspaces/${options.workspaceId}/invitations`, { token: options.token });
+	return Array.isArray(data) ? data : data.invitations ?? [];
+}
+async function createWorkspaceInvitation(context, options) {
+	const url = `${options.baseUrl}/api/workspaces/${options.workspaceId}/invitations`;
+	const body = {};
+	if (options.email !== void 0) body.email = options.email;
+	if (options.role !== void 0) body.role = options.role;
+	const data = await requestJson(context, url, {
+		method: "POST",
+		token: options.token,
+		body
+	});
+	if ("id" in data && typeof data.id === "string") return data;
+	const nested = data.invitation;
+	if (nested) return nested;
+	throw new CliError("Invalid response from invitation endpoint", EXIT_CODES.ERROR);
+}
+async function listWorkspaceHistory(context, options) {
+	const params = new URLSearchParams({ limit: String(options.limit) });
+	if (options.model) params.set("model", options.model);
+	return (await requestJson(context, `${options.baseUrl}/api/workspaces/${options.workspaceId}/history?${params.toString()}`, { token: options.token })).history;
+}
+
+//#endregion
+//#region src/command-context.ts
+function getOptionalSupabaseConfig() {
+	try {
+		return resolveSupabaseConfig();
+	} catch {
+		return null;
+	}
+}
+async function requireAuthToken(context) {
+	const resolvedToken = await resolveAuthToken(context, getOptionalSupabaseConfig());
+	if (!resolvedToken) throw new CliError("Not authenticated. Run `donebear auth login`.", EXIT_CODES.AUTH_REQUIRED);
+	return {
+		token: resolvedToken.token,
+		resolvedToken
+	};
+}
+async function resolveCommandContext(context) {
+	const { token, resolvedToken } = await requireAuthToken(context);
+	if (!token) throw new CliError("Missing access token", EXIT_CODES.AUTH_REQUIRED);
+	return {
+		token,
+		resolvedToken,
+		apiBaseUrl: resolveApiBaseUrl(context),
+		localContext: await ensureLocalContext()
+	};
+}
+function requireUserId(resolvedToken) {
+	const userId = resolvedToken.user?.id ?? null;
+	if (!(typeof userId === "string" && userId.length > 0)) throw new CliError("Could not determine user id from auth token", EXIT_CODES.AUTH_REQUIRED);
+	return userId;
+}
+
+//#endregion
+//#region src/task-defaults.ts
+const DAY_MS = 1440 * 60 * 1e3;
+function startOfDayEpoch(now) {
+	return new Date(now.getFullYear(), now.getMonth(), now.getDate()).getTime();
+}
+function buildTaskStartFields(view, now = /* @__PURE__ */ new Date()) {
+	const today = startOfDayEpoch(now);
+	const tomorrow = today + DAY_MS;
+	switch (view) {
+		case "inbox": return {
+			start: "not_started",
+			startBucket: "today",
+			startDate: null,
+			todayIndexReferenceDate: null
+		};
+		case "anytime": return {
+			start: "started",
+			startBucket: "today",
+			startDate: null,
+			todayIndexReferenceDate: null
+		};
+		case "today": return {
+			start: "started",
+			startBucket: "today",
+			startDate: today,
+			todayIndexReferenceDate: today
+		};
+		case "upcoming": return {
+			start: "started",
+			startBucket: "upcoming",
+			startDate: tomorrow,
+			todayIndexReferenceDate: null
+		};
+		case "someday": return {
+			start: "someday",
+			startBucket: "today",
+			startDate: null,
+			todayIndexReferenceDate: null
+		};
+		default: return {
+			start: "not_started",
+			startBucket: "today",
+			startDate: null,
+			todayIndexReferenceDate: null
+		};
+	}
+}
+function getTaskState(task) {
+	if (task.archivedAt !== null) return "archived";
+	if (task.completedAt !== null) return "done";
+	return "open";
+}
+function formatEpochDate(epochMs) {
+	if (epochMs === null) return null;
+	const date = new Date(epochMs);
+	if (Number.isNaN(date.getTime())) return null;
+	return date.toISOString();
+}
+function formatShortDate(epochMs) {
+	const iso = formatEpochDate(epochMs);
+	if (!iso) return null;
+	return iso.slice(0, 10);
+}
+
+//#endregion
+//#region src/command-helpers.ts
+function normalizeWorkspaceRef(value) {
+	const normalized = value?.trim() ?? "";
+	return normalized.length > 0 ? normalized : null;
+}
+function parseTaskState(value) {
+	switch (value.trim().toLowerCase()) {
+		case "open":
+		case "todo":
+		case "pending": return "open";
+		case "done":
+		case "complete":
+		case "completed": return "done";
+		case "archived":
+		case "archive": return "archived";
+		case "all": return "all";
+		default: throw new Error(`Invalid state "${value}". Expected one of: open, done, archived, all.`);
+	}
+}
+function toTaskMarker(task) {
+	const state = getTaskState(task);
+	if (state === "done") return "[x]";
+	if (state === "archived") return "[-]";
+	return "[ ]";
+}
+
+//#endregion
+//#region src/workspace-context.ts
+const WORKSPACE_URL_KEY_REGEX = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+function normalize(value) {
+	return value.trim().toLowerCase();
+}
+function byReference(workspaces, reference) {
+	const normalized = normalize(reference);
+	for (const workspace of workspaces) {
+		if (workspace.id === reference) return workspace;
+		if (workspace.urlKey && normalize(workspace.urlKey) === normalized) return workspace;
+		if (normalize(workspace.name) === normalized) return workspace;
+	}
+	return null;
+}
+function toWorkspaceUrlKey(name) {
+	return name.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").replace(/-{2,}/g, "-").slice(0, 50);
+}
+function isValidWorkspaceUrlKey(value) {
+	return WORKSPACE_URL_KEY_REGEX.test(value) && value.length >= 3;
+}
+async function resolveWorkspace(context, options) {
+	const workspaces = await listWorkspaces(context, {
+		token: options.token,
+		baseUrl: options.apiBaseUrl
+	});
+	if (workspaces.length === 0) throw new Error("No workspaces available for this account");
+	if (options.workspaceRef) {
+		const selected = byReference(workspaces, options.workspaceRef);
+		if (!selected) throw new Error(`Workspace "${options.workspaceRef}" not found. Run \`donebear workspace list\`.`);
+		return {
+			workspace: selected,
+			autoSelected: false
+		};
+	}
+	if (options.storedWorkspaceId) {
+		const selected = byReference(workspaces, options.storedWorkspaceId);
+		if (selected) return {
+			workspace: selected,
+			autoSelected: false
+		};
+	}
+	if (workspaces.length === 1) {
+		const workspace = workspaces[0];
+		if (!workspace) throw new Error("No workspaces available for this account");
+		await setCurrentWorkspace(workspace.id);
+		return {
+			workspace,
+			autoSelected: true
+		};
+	}
+	throw new Error("No default workspace selected. Run `donebear workspace use <id-or-slug>`.");
+}
+
+//#endregion
+//#region src/commands/history.ts
+const DEFAULT_HISTORY_LIMIT = 50;
+const ACTION_LABELS = {
+	I: "CREATE",
+	U: "UPDATE",
+	A: "ARCHIVE",
+	D: "DELETE",
+	V: "UNARCHIVE"
+};
+function formatActionCode(action) {
+	return ACTION_LABELS[action] ?? action;
+}
+function formatHistoryDate(isoString) {
+	const date = new Date(isoString);
+	if (Number.isNaN(date.getTime())) return isoString;
+	return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, "0")}-${String(date.getDate()).padStart(2, "0")} ${String(date.getHours()).padStart(2, "0")}:${String(date.getMinutes()).padStart(2, "0")}`;
+}
+function extractPayloadTitle(entry) {
+	if (!entry.payload) return "";
+	const title = entry.payload.title;
+	if (typeof title === "string") return ` (title: "${title}")`;
+	return "";
+}
+async function runHistory(context, workspaceOverride, options) {
+	const commandContext = await resolveCommandContext(context);
+	const { workspace } = await resolveWorkspace(context, {
+		token: commandContext.token,
+		apiBaseUrl: commandContext.apiBaseUrl,
+		workspaceRef: workspaceOverride ?? normalizeWorkspaceRef(options.workspace),
+		storedWorkspaceId: commandContext.localContext.workspaceId
+	});
+	try {
+		const history = await listWorkspaceHistory(context, {
+			baseUrl: commandContext.apiBaseUrl,
+			token: commandContext.token,
+			workspaceId: workspace.id,
+			limit: options.limit,
+			model: options.model
+		});
+		if (context.json) {
+			writeJson({
+				workspace,
+				history
+			});
+			return;
+		}
+		const historyHeaders = [
+			"date",
+			"action",
+			"model",
+			"modelId",
+			"title"
+		];
+		const historyRows = history.map((entry) => [
+			formatHistoryDate(entry.createdAt),
+			formatActionCode(entry.action),
+			entry.modelName,
+			entry.modelId.slice(0, 8),
+			typeof entry.payload?.title === "string" ? entry.payload.title : ""
+		]);
+		if (writeFormattedRows(context, history.length, historyHeaders, historyRows)) return;
+		if (history.length === 0) {
+			writeInfo(context, "No history entries found.");
+			return;
+		}
+		writeInfo(context, `History for ${workspace.name}:`);
+		for (const entry of history) {
+			const date = formatHistoryDate(entry.createdAt);
+			const action = formatActionCode(entry.action);
+			const modelId = entry.modelId.slice(0, 8);
+			const title = extractPayloadTitle(entry);
+			writeInfo(context, `${date}  ${action}  ${entry.modelName}  ${modelId}...${title}`);
+		}
+	} catch {
+		writeWarning(context, "History is not available for this server version.");
+		writeWarning(context, "Upgrade your manage-api to enable audit logs.");
+	}
+}
+function registerHistoryCommand(program, workspaceOverride) {
+	program.command("history").description("Show recent workspace audit log").option("-w, --workspace <workspace>", "Workspace id, slug, or exact name").option("--model <model>", "Filter by model name: Task|Project|Label|Team").option("-n, --limit <count>", "Maximum number of entries", (value) => parsePositiveInteger(value, "Limit"), DEFAULT_HISTORY_LIMIT).addHelpText("after", `
+Examples:
+  donebear history
+  donebear history --model Task --limit 20
+  donebear history --format csv
+`).action(async (options, command) => {
+		const context = contextFromCommand(command);
+		await runWithErrorHandling(context, async () => {
+			await runHistory(context, workspaceOverride, options);
+		});
+	});
+}
+
+//#endregion
+//#region src/commands/interactive.ts
+const HISTORY_FILE = join(CONFIG_DIR, "history.json");
+const MAX_HISTORY = 200;
+function isHistoryFile(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const record = value;
+	return record.version === 1 && Array.isArray(record.entries) && record.entries.every((e) => typeof e === "string");
+}
+async function loadHistory(historyFile) {
+	try {
+		const raw = await readFile(historyFile, "utf8");
+		const parsed = JSON.parse(raw);
+		if (isHistoryFile(parsed)) return parsed.entries;
+		return [];
+	} catch {
+		return [];
+	}
+}
+function tokenize(input) {
+	const tokens = [];
+	let current = "";
+	let inQuote = false;
+	let quoteChar = "";
+	for (const char of input) if (inQuote) if (char === quoteChar) inQuote = false;
+	else current += char;
+	else if (char === "\"" || char === "'") {
+		inQuote = true;
+		quoteChar = char;
+	} else if (char === " ") {
+		if (current.length > 0) {
+			tokens.push(current);
+			current = "";
+		}
+	} else current += char;
+	if (current.length > 0) tokens.push(current);
+	return tokens;
+}
+function buildCompleter(program) {
+	return (line) => {
+		const allCommands = program.commands.flatMap((cmd) => [cmd.name(), ...cmd.aliases()]);
+		const hits = allCommands.filter((c) => c.startsWith(line));
+		return [hits.length > 0 ? hits : allCommands, line];
+	};
+}
+async function runInteractiveMode(context, program) {
+	const history = await loadHistory(HISTORY_FILE);
+	const rl = createInterface({
+		input: process.stdin,
+		output: process.stdout,
+		prompt: "donebear> ",
+		historySize: MAX_HISTORY,
+		completer: buildCompleter(program)
+	});
+	for (const entry of [...history].reverse()) rl.history.push(entry);
+	writeSuccess(context, "Done Bear interactive mode. Type \"exit\" or Ctrl+D to quit.");
+	writeInfo(context, "Commands: task, workspace, project, label, team, today, search, auth, whoami");
+	rl.prompt();
+	const sessionEntries = [];
+	for await (const line of rl) {
+		const trimmed = line.trim();
+		if (!trimmed) {
+			rl.prompt();
+			continue;
+		}
+		if (trimmed === "exit" || trimmed === "quit" || trimmed === ":q") break;
+		const tokens = tokenize(trimmed);
+		try {
+			await program.parseAsync([
+				"node",
+				"donebear",
+				...tokens
+			]);
+		} catch {}
+		sessionEntries.push(trimmed);
+		rl.prompt();
+	}
+	rl.close();
+	if (sessionEntries.length > 0) try {
+		const payload = {
+			version: 1,
+			entries: [...await loadHistory(HISTORY_FILE), ...sessionEntries].slice(-MAX_HISTORY)
+		};
+		await mkdir(CONFIG_DIR, {
+			recursive: true,
+			mode: 448
+		});
+		await writeFile(HISTORY_FILE, `${JSON.stringify(payload, null, 2)}\n`, {
+			encoding: "utf8",
+			mode: 384
+		});
+	} catch {}
+}
+
+//#endregion
+//#region src/commands/label.ts
+function sortLabels(labels, sort) {
+	const sorted = [...labels];
+	if (sort === "alpha") sorted.sort((a, b) => a.title.localeCompare(b.title));
+	else sorted.sort((a, b) => a.title.localeCompare(b.title));
+	return sorted;
+}
+async function resolveLabel(context, options) {
+	const { workspace } = await resolveWorkspace(context, {
+		token: options.commandContext.token,
+		apiBaseUrl: options.commandContext.apiBaseUrl,
+		workspaceRef: options.workspaceRef,
+		storedWorkspaceId: options.commandContext.localContext.workspaceId
+	});
+	const labels = await loadLabelsByWorkspace(context, {
+		baseUrl: options.commandContext.apiBaseUrl,
+		token: options.commandContext.token,
+		workspaceId: workspace.id
+	});
+	const normalized = options.labelRef.trim().toLowerCase();
+	const found = labels.find((l) => l.id === options.labelRef || l.title.toLowerCase() === normalized || l.id.startsWith(options.labelRef));
+	if (!found) throw new Error(`Label "${options.labelRef}" not found.`);
+	return found;
+}
+async function runLabelList(context, options) {
+	const commandContext = await resolveCommandContext(context);
+	const { workspace, autoSelected } = await resolveWorkspace(context, {
+		token: commandContext.token,
+		apiBaseUrl: commandContext.apiBaseUrl,
+		workspaceRef: normalizeWorkspaceRef(options.workspace),
+		storedWorkspaceId: commandContext.localContext.workspaceId
+	});
+	const sorted = sortLabels(await loadLabelsByWorkspace(context, {
+		baseUrl: commandContext.apiBaseUrl,
+		token: commandContext.token,
+		workspaceId: workspace.id
+	}), options.sort);
+	if (context.json) {
+		writeJson({
+			workspace,
+			autoSelected,
+			total: sorted.length,
+			labels: sorted
+		});
+		return;
+	}
+	const headers = [
+		"id",
+		"title",
+		"createdAt",
+		"updatedAt"
+	];
+	const rows = sorted.map((l) => [
+		l.id,
+		l.title,
+		formatEpochDate(l.createdAt) ?? "",
+		formatEpochDate(l.updatedAt) ?? ""
+	]);
+	if (writeFormattedRows(context, sorted.length, headers, rows)) return;
+	if (autoSelected) writeInfo(context, `Auto-selected workspace: ${workspace.name}`);
+	if (sorted.length === 0) {
+		writeInfo(context, "No labels found.");
+		return;
+	}
+	writeInfo(context, `${workspace.name} (${sorted.length} label(s))`);
+	for (const label of sorted) writeInfo(context, `${label.id.slice(0, 8)}  ${label.title}`);
+	if (context.copy) copyToClipboard(sorted.map((l) => `${l.id.slice(0, 8)}  ${l.title}`).join("\n"));
+}
+async function runLabelShow(context, labelRef, options) {
+	const label = await resolveLabel(context, {
+		labelRef,
+		commandContext: await resolveCommandContext(context),
+		workspaceRef: normalizeWorkspaceRef(options.workspace)
+	});
+	if (context.json) {
+		writeJson({
+			label,
+			createdAtIso: formatEpochDate(label.createdAt),
+			updatedAtIso: formatEpochDate(label.updatedAt)
+		});
+		return;
+	}
+	writeSuccess(context, label.title);
+	writeInfo(context, `id: ${label.id}`);
+	writeInfo(context, `workspaceId: ${label.workspaceId}`);
+	writeInfo(context, `createdAt: ${formatEpochDate(label.createdAt) ?? "(none)"}`);
+	writeInfo(context, `updatedAt: ${formatEpochDate(label.updatedAt) ?? "(none)"}`);
+}
+function registerLabelCommands(program, workspaceOverride) {
+	const label = program.command("label").alias("labels").description("Manage labels").addHelpText("after", `
+Examples:
+  donebear label
+  donebear label list --sort alpha
+  donebear label show bug
+`).action(async (_options, command) => {
+		const context = contextFromCommand(command);
+		await runWithErrorHandling(context, async () => {
+			await runLabelList(context, { sort: "alpha" });
+		});
+	});
+	label.command("list").alias("ls").description("List labels").option("-w, --workspace <workspace>", "Workspace id, slug, or exact name").option("--sort <order>", "Sort order: alpha|count", "alpha").action(async (options, command) => {
+		const context = contextFromCommand(command);
+		await runWithErrorHandling(context, async () => {
+			await runLabelList(context, {
+				...options,
+				workspace: workspaceOverride ?? normalizeWorkspaceRef(options.workspace) ?? void 0
+			});
+		});
+	});
+	label.command("show").description("Show label details").argument("<id-or-title>", "Label id, title, or id prefix").option("-w, --workspace <workspace>", "Workspace id, slug, or exact name").action(async (labelRef, options, command) => {
+		const context = contextFromCommand(command);
+		await runWithErrorHandling(context, async () => {
+			await runLabelShow(context, labelRef, { workspace: workspaceOverride ?? normalizeWorkspaceRef(options.workspace) ?? void 0 });
+		});
+	});
+}
+
+//#endregion
+//#region src/commands/project.ts
+const ISO_YMD_REGEX$1 = /^(\d{4})-(\d{2})-(\d{2})$/;
+function parseProjectStatus(value) {
+	switch (value.trim().toLowerCase()) {
+		case "active": return "active";
+		case "done":
+		case "complete":
+		case "completed": return "done";
+		case "archived":
+		case "archive": return "archived";
+		case "all": return "all";
+		default: throw new Error(`Invalid status "${value}". Expected one of: active, done, archived, all.`);
+	}
+}
+function getProjectStatus(project) {
+	if (project.archivedAt !== null) return "archived";
+	if (project.completedAt !== null) return "done";
+	return "active";
+}
+function parseTargetDate(value) {
+	if (!value) return null;
+	const trimmed = value.trim();
+	if (ISO_YMD_REGEX$1.exec(trimmed)) {
+		const year = Number.parseInt(trimmed.slice(0, 4), 10);
+		const month = Number.parseInt(trimmed.slice(5, 7), 10);
+		const day = Number.parseInt(trimmed.slice(8, 10), 10);
+		const date = new Date(year, month - 1, day);
+		if (Number.isNaN(date.getTime())) throw new Error(`Invalid target date: ${value}`);
+		return date.getTime();
+	}
+	const parsed = Date.parse(trimmed);
+	if (Number.isNaN(parsed)) throw new Error(`Invalid target date: ${value}`);
+	return parsed;
+}
+const WHITESPACE_REGEX = /\s+/;
+function autoGenerateKey(name) {
+	return name.trim().split(WHITESPACE_REGEX).map((word) => word[0]?.toUpperCase() ?? "").join("").replace(/[^A-Z0-9]/g, "").slice(0, 5) || "PROJ";
+}
+function filterProjects(projects, status) {
+	if (status === "all") return projects;
+	return projects.filter((p) => getProjectStatus(p) === status);
+}
+function sortProjectsByUpdatedDesc(projects) {
+	return [...projects].sort((a, b) => (b.updatedAt ?? 0) - (a.updatedAt ?? 0));
+}
+async function resolveProjectReference(context, options) {
+	const { workspace } = await resolveWorkspace(context, {
+		token: options.commandContext.token,
+		apiBaseUrl: options.commandContext.apiBaseUrl,
+		workspaceRef: options.workspaceRef,
+		storedWorkspaceId: options.commandContext.localContext.workspaceId
+	});
+	const projects = await loadProjectsByWorkspace(context, {
+		baseUrl: options.commandContext.apiBaseUrl,
+		token: options.commandContext.token,
+		workspaceId: workspace.id
+	});
+	const normalized = options.projectRef.trim().toLowerCase();
+	const found = projects.find((p) => p.id === options.projectRef || p.key.toLowerCase() === normalized || p.id.startsWith(options.projectRef));
+	if (!found) throw new Error(`Project "${options.projectRef}" not found.`);
+	return {
+		project: found,
+		workspace
+	};
+}
+async function runProjectList(context, options) {
+	const commandContext = await resolveCommandContext(context);
+	const requestedStatus = parseProjectStatus(options.status);
+	const { workspace, autoSelected } = await resolveWorkspace(context, {
+		token: commandContext.token,
+		apiBaseUrl: commandContext.apiBaseUrl,
+		workspaceRef: normalizeWorkspaceRef(options.workspace),
+		storedWorkspaceId: commandContext.localContext.workspaceId
+	});
+	const filtered = filterProjects(sortProjectsByUpdatedDesc(await loadProjectsByWorkspace(context, {
+		baseUrl: commandContext.apiBaseUrl,
+		token: commandContext.token,
+		workspaceId: workspace.id
+	})), requestedStatus);
+	if (context.json) {
+		writeJson({
+			workspace,
+			autoSelected,
+			status: requestedStatus,
+			total: filtered.length,
+			projects: filtered
+		});
+		return;
+	}
+	const headers = [
+		"id",
+		"key",
+		"name",
+		"status",
+		"targetDate",
+		"updatedAt"
+	];
+	const rows = filtered.map((p) => [
+		p.id,
+		p.key,
+		p.name,
+		getProjectStatus(p),
+		formatShortDate(p.targetDate) ?? "",
+		formatShortDate(p.updatedAt) ?? ""
+	]);
+	if (writeFormattedRows(context, filtered.length, headers, rows)) return;
+	if (autoSelected) writeInfo(context, `Auto-selected workspace: ${workspace.name}`);
+	if (filtered.length === 0) {
+		writeInfo(context, "No projects found.");
+		return;
+	}
+	writeInfo(context, `${workspace.name} (${filtered.length} project(s))`);
+	for (const project of filtered) {
+		const status = getProjectStatus(project);
+		const target = formatShortDate(project.targetDate);
+		const suffix = target ? `  due ${target}` : "";
+		writeInfo(context, `${project.id.slice(0, 8)}  [${project.key}]  ${project.name}  (${status})${suffix}`);
+	}
+	if (context.copy) copyToClipboard(filtered.map((p) => `${p.id.slice(0, 8)}  [${p.key}]  ${p.name}  (${getProjectStatus(p)})`).join("\n"));
+}
+async function runProjectShow(context, projectRef, options) {
+	const { project, workspace } = await resolveProjectReference(context, {
+		projectRef,
+		commandContext: await resolveCommandContext(context),
+		workspaceRef: normalizeWorkspaceRef(options.workspace)
+	});
+	if (context.json) {
+		writeJson({
+			project,
+			status: getProjectStatus(project),
+			workspace,
+			createdAtIso: formatEpochDate(project.createdAt),
+			updatedAtIso: formatEpochDate(project.updatedAt),
+			completedAtIso: formatEpochDate(project.completedAt),
+			archivedAtIso: formatEpochDate(project.archivedAt),
+			targetDateIso: formatEpochDate(project.targetDate)
+		});
+		return;
+	}
+	writeSuccess(context, project.name);
+	writeInfo(context, `id: ${project.id}`);
+	writeInfo(context, `key: ${project.key}`);
+	writeInfo(context, `status: ${getProjectStatus(project)}`);
+	writeInfo(context, `workspaceId: ${project.workspaceId}`);
+	writeInfo(context, `targetDate: ${formatEpochDate(project.targetDate) ?? "(none)"}`);
+	writeInfo(context, `createdAt: ${formatEpochDate(project.createdAt) ?? "(none)"}`);
+	writeInfo(context, `updatedAt: ${formatEpochDate(project.updatedAt) ?? "(none)"}`);
+	if (project.description) writeInfo(context, `description: ${project.description}`);
+}
+async function runProjectAdd(context, name, options) {
+	const commandContext = await resolveCommandContext(context);
+	const userId = requireUserId(commandContext.resolvedToken);
+	const normalizedName = name.trim();
+	if (normalizedName.length === 0) throw new Error("Project name cannot be empty.");
+	const { workspace, autoSelected } = await resolveWorkspace(context, {
+		token: commandContext.token,
+		apiBaseUrl: commandContext.apiBaseUrl,
+		workspaceRef: normalizeWorkspaceRef(options.workspace),
+		storedWorkspaceId: commandContext.localContext.workspaceId
+	});
+	const projectId = randomUUID();
+	const now = Date.now();
+	const key = options.key?.trim().toUpperCase() || autoGenerateKey(normalizedName);
+	await mutateModel(context, {
+		baseUrl: commandContext.apiBaseUrl,
+		token: commandContext.token,
+		request: {
+			batchId: randomUUID(),
+			transactions: [{
+				clientTxId: randomUUID(),
+				clientId: commandContext.localContext.clientId,
+				modelName: "Project",
+				modelId: projectId,
+				action: "INSERT",
+				payload: {
+					name: normalizedName,
+					key,
+					description: options.description?.trim() || null,
+					status: "active",
+					sortOrder: 0,
+					targetDate: parseTargetDate(options.targetDate),
+					completedAt: null,
+					archivedAt: null,
+					creatorId: userId,
+					workspaceId: workspace.id,
+					createdAt: now,
+					updatedAt: now
+				}
+			}]
+		}
+	});
+	if (context.json) {
+		writeJson({
+			created: true,
+			id: projectId,
+			key,
+			workspaceId: workspace.id,
+			workspaceName: workspace.name,
+			autoSelected
+		});
+		return;
+	}
+	if (autoSelected) writeInfo(context, `Auto-selected workspace: ${workspace.name}`);
+	writeSuccess(context, `Added project: ${normalizedName}`);
+	writeInfo(context, `id: ${projectId}`);
+	writeInfo(context, `key: ${key}`);
+}
+function buildProjectUpdates(options) {
+	if (options.clearDescription && typeof options.description === "string") throw new Error("Use either --description or --clear-description, not both.");
+	if (options.clearTargetDate && typeof options.targetDate === "string") throw new Error("Use either --target-date or --clear-target-date, not both.");
+	const updates = {};
+	if (typeof options.name === "string") {
+		const name = options.name.trim();
+		if (name.length === 0) throw new Error("Project name cannot be empty.");
+		updates.name = name;
+	}
+	if (options.clearDescription) updates.description = null;
+	else if (typeof options.description === "string") {
+		const desc = options.description.trim();
+		updates.description = desc.length > 0 ? desc : null;
+	}
+	if (options.clearTargetDate) updates.targetDate = null;
+	else if (typeof options.targetDate === "string") updates.targetDate = parseTargetDate(options.targetDate);
+	if (typeof options.status === "string") applyStatusToUpdates(updates, parseProjectStatus(options.status));
+	if (Object.keys(updates).length === 0) throw new Error("No updates provided. Use --name, --description, --clear-description, --status, --target-date, or --clear-target-date.");
+	updates.updatedAt = Date.now();
+	return updates;
+}
+function applyStatusToUpdates(updates, status) {
+	if (status === "done") {
+		updates.completedAt = Date.now();
+		updates.archivedAt = null;
+	} else if (status === "active") {
+		updates.completedAt = null;
+		updates.archivedAt = null;
+	} else if (status === "archived") updates.archivedAt = Date.now();
+}
+async function runProjectEdit(context, projectRef, options) {
+	const updates = buildProjectUpdates(options);
+	const commandContext = await resolveCommandContext(context);
+	const { project } = await resolveProjectReference(context, {
+		projectRef,
+		commandContext,
+		workspaceRef: normalizeWorkspaceRef(options.workspace)
+	});
+	await mutateModel(context, {
+		baseUrl: commandContext.apiBaseUrl,
+		token: commandContext.token,
+		request: {
+			batchId: randomUUID(),
+			transactions: [{
+				clientTxId: randomUUID(),
+				clientId: commandContext.localContext.clientId,
+				modelName: "Project",
+				modelId: project.id,
+				action: "UPDATE",
+				payload: updates
+			}]
+		}
+	});
+	if (context.json) {
+		writeJson({
+			ok: true,
+			id: project.id,
+			action: "UPDATE"
+		});
+		return;
+	}
+	writeSuccess(context, `Updated project: ${project.id}`);
+}
+async function runProjectMutation(context, projectRef, payload) {
+	const commandContext = await resolveCommandContext(context);
+	const { project } = await resolveProjectReference(context, {
+		projectRef,
+		commandContext,
+		workspaceRef: payload.workspaceRef
+	});
+	await mutateModel(context, {
+		baseUrl: commandContext.apiBaseUrl,
+		token: commandContext.token,
+		request: {
+			batchId: randomUUID(),
+			transactions: [{
+				clientTxId: randomUUID(),
+				clientId: commandContext.localContext.clientId,
+				modelName: "Project",
+				modelId: project.id,
+				action: payload.action,
+				payload: payload.data
+			}]
+		}
+	});
+	if (context.json) {
+		writeJson({
+			ok: true,
+			id: project.id,
+			action: payload.action
+		});
+		return;
+	}
+	writeSuccess(context, `${payload.successMessage}: ${project.id}`);
+}
+function registerProjectCommands(program, workspaceOverride) {
+	const project = program.command("project").alias("projects").description("Manage projects").addHelpText("after", `
+Examples:
+  donebear project
+  donebear project add "Q1 Launch" --key LAUNCH
+  donebear project list --status active
+  donebear project edit LAUNCH --target-date 2026-03-31
+`).action(async (_options, command) => {
+		const context = contextFromCommand(command);
+		await runWithErrorHandling(context, async () => {
+			await runProjectList(context, { status: "active" });
+		});
+	});
+	project.command("list").alias("ls").description("List projects").option("-w, --workspace <workspace>", "Workspace id, slug, or exact name").option("-s, --status <status>", "active|done|archived|all", "active").action(async (options, command) => {
+		const context = contextFromCommand(command);
+		await runWithErrorHandling(context, async () => {
+			await runProjectList(context, {
+				...options,
+				workspace: workspaceOverride ?? normalizeWorkspaceRef(options.workspace) ?? void 0
+			});
+		});
+	});
+	project.command("show").description("Show project details").argument("<id-or-key>", "Project id, key, or id prefix").option("-w, --workspace <workspace>", "Workspace id, slug, or exact name").action(async (projectRef, options, command) => {
+		const context = contextFromCommand(command);
+		await runWithErrorHandling(context, async () => {
+			await runProjectShow(context, projectRef, { workspace: workspaceOverride ?? normalizeWorkspaceRef(options.workspace) ?? void 0 });
+		});
+	});
+	project.command("add").alias("create").description("Create a project").argument("<name>", "Project name").option("-w, --workspace <workspace>", "Workspace id, slug, or exact name").option("--key <KEY>", "Short project key (auto-generated if not provided)").option("-d, --description <text>", "Project description").option("--target-date <date>", "Target date (YYYY-MM-DD)").action(async (name, options, command) => {
+		const context = contextFromCommand(command);
+		await runWithErrorHandling(context, async () => {
+			await runProjectAdd(context, name, {
+				...options,
+				workspace: workspaceOverride ?? normalizeWorkspaceRef(options.workspace) ?? void 0
+			});
+		});
+	});
+	project.command("edit").description("Update project fields").argument("<id-or-key>", "Project id, key, or id prefix").option("-w, --workspace <workspace>", "Workspace id, slug, or exact name").option("--name <name>", "Replace project name").option("-d, --description <text>", "Replace project description").option("--clear-description", "Clear project description").option("--status <status>", "Set status (active|done|archived)").option("--target-date <date>", "Set target date (YYYY-MM-DD)").option("--clear-target-date", "Clear target date").action(async (projectRef, options, command) => {
+		const context = contextFromCommand(command);
+		await runWithErrorHandling(context, async () => {
+			await runProjectEdit(context, projectRef, {
+				...options,
+				workspace: workspaceOverride ?? normalizeWorkspaceRef(options.workspace) ?? void 0
+			});
+		});
+	});
+	project.command("done").alias("complete").description("Mark a project as completed").argument("<id-or-key>", "Project id, key, or id prefix").option("-w, --workspace <workspace>", "Workspace id, slug, or exact name").action(async (projectRef, options, command) => {
+		const context = contextFromCommand(command);
+		await runWithErrorHandling(context, async () => {
+			const now = Date.now();
+			await runProjectMutation(context, projectRef, {
+				workspaceRef: workspaceOverride ?? normalizeWorkspaceRef(options.workspace),
+				action: "UPDATE",
+				data: {
+					completedAt: now,
+					updatedAt: now
+				},
+				successMessage: "Marked done"
+			});
+		});
+	});
+	project.command("archive").description("Archive a project").argument("<id-or-key>", "Project id, key, or id prefix").option("-w, --workspace <workspace>", "Workspace id, slug, or exact name").action(async (projectRef, options, command) => {
+		const context = contextFromCommand(command);
+		await runWithErrorHandling(context, async () => {
+			await runProjectMutation(context, projectRef, {
+				workspaceRef: workspaceOverride ?? normalizeWorkspaceRef(options.workspace),
+				action: "ARCHIVE",
+				data: { archivedAt: Date.now() },
+				successMessage: "Archived"
+			});
+		});
+	});
+	project.command("unarchive").alias("restore").description("Unarchive a project").argument("<id-or-key>", "Project id, key, or id prefix").option("-w, --workspace <workspace>", "Workspace id, slug, or exact name").action(async (projectRef, options, command) => {
+		const context = contextFromCommand(command);
+		await runWithErrorHandling(context, async () => {
+			await runProjectMutation(context, projectRef, {
+				workspaceRef: workspaceOverride ?? normalizeWorkspaceRef(options.workspace),
+				action: "UNARCHIVE",
+				data: {},
+				successMessage: "Unarchived"
+			});
+		});
+	});
+}
+
+//#endregion
+//#region src/commands/task.ts
+const ISO_YMD_REGEX = /^(\d{4})-(\d{2})-(\d{2})$/;
+const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+const DEFAULT_TASK_LIST_LIMIT = 20;
+const VALID_TASK_VIEWS = new Set([
+	"inbox",
+	"anytime",
+	"today",
+	"upcoming",
+	"someday"
+]);
+function parseTaskView(value) {
+	const normalized = value.trim().toLowerCase();
+	if (VALID_TASK_VIEWS.has(normalized)) return normalized;
+	throw new Error(`Invalid view "${value}". Expected one of: inbox, anytime, today, upcoming, someday.`);
+}
+function parseDeadline(value) {
+	if (!value) return null;
+	const trimmed = value.trim();
+	if (ISO_YMD_REGEX.exec(trimmed)) {
+		const year = Number.parseInt(trimmed.slice(0, 4), 10);
+		const month = Number.parseInt(trimmed.slice(5, 7), 10);
+		const day = Number.parseInt(trimmed.slice(8, 10), 10);
+		const date = new Date(year, month - 1, day);
+		if (Number.isNaN(date.getTime())) throw new Error(`Invalid deadline date: ${value}`);
+		return date.getTime();
+	}
+	const parsed = Date.parse(trimmed);
+	if (Number.isNaN(parsed)) throw new Error(`Invalid deadline date: ${value}`);
+	return parsed;
+}
+function sortTasksByUpdatedDesc(tasks) {
+	return [...tasks].sort((a, b) => (b.updatedAt ?? 0) - (a.updatedAt ?? 0));
+}
+async function resolveTaskReference(context, options) {
+	const taskRef = options.taskRef.trim();
+	if (!taskRef) throw new Error("Task id is required.");
+	const exact = await loadTaskById(context, {
+		baseUrl: options.commandContext.apiBaseUrl,
+		token: options.commandContext.token,
+		taskId: taskRef
+	});
+	if (exact) return exact;
+	if (UUID_REGEX.test(taskRef)) throw new Error(`Task "${taskRef}" not found.`);
+	if (taskRef.length < 4) throw new Error("Task id prefix must be at least 4 characters.");
+	const { workspace, autoSelected } = await resolveWorkspace(context, {
+		token: options.commandContext.token,
+		apiBaseUrl: options.commandContext.apiBaseUrl,
+		workspaceRef: options.workspaceRef,
+		storedWorkspaceId: options.commandContext.localContext.workspaceId
+	});
+	const matches = (await loadTasksByWorkspace(context, {
+		baseUrl: options.commandContext.apiBaseUrl,
+		token: options.commandContext.token,
+		workspaceId: workspace.id
+	})).filter((task) => task.id.startsWith(taskRef));
+	if (matches.length === 0) throw new Error(`Task "${taskRef}" not found.`);
+	if (matches.length === 1) {
+		const [match] = matches;
+		if (!match) throw new Error(`Task "${taskRef}" not found.`);
+		if (autoSelected && !context.json) writeInfo(context, `Auto-selected workspace: ${workspace.name}`);
+		return match;
+	}
+	throw new Error(`Task prefix "${taskRef}" is ambiguous (${matches.length} matches). Use the full id.`);
+}
+function filterTasks(tasks, options) {
+	const stateFiltered = options.state === "all" ? tasks : tasks.filter((task) => getTaskState(task) === options.state);
+	if (!options.search) return stateFiltered;
+	const query = options.search.trim().toLowerCase();
+	if (query.length === 0) return stateFiltered;
+	return stateFiltered.filter((task) => {
+		const title = task.title.toLowerCase();
+		const notes = task.description?.toLowerCase() ?? "";
+		return title.includes(query) || notes.includes(query);
+	});
+}
+async function runTaskList(context, options, workspaceOverride) {
+	const commandContext = await resolveCommandContext(context);
+	const requestedState = parseTaskState(options.state);
+	const { workspace, autoSelected } = await resolveWorkspace(context, {
+		token: commandContext.token,
+		apiBaseUrl: commandContext.apiBaseUrl,
+		workspaceRef: workspaceOverride ?? normalizeWorkspaceRef(options.workspace),
+		storedWorkspaceId: commandContext.localContext.workspaceId
+	});
+	const filtered = filterTasks(sortTasksByUpdatedDesc(await loadTasksByWorkspace(context, {
+		baseUrl: commandContext.apiBaseUrl,
+		token: commandContext.token,
+		workspaceId: workspace.id
+	})), {
+		state: requestedState,
+		search: options.search?.trim() ?? null
+	});
+	const limited = filtered.slice(0, options.limit);
+	if (context.json) {
+		writeJson({
+			workspace,
+			autoSelected,
+			state: requestedState,
+			total: filtered.length,
+			count: limited.length,
+			tasks: limited
+		});
+		return;
+	}
+	const headers = [
+		"id",
+		"title",
+		"state",
+		"deadline"
+	];
+	const rows = limited.map((task) => [
+		task.id,
+		task.title,
+		getTaskState(task),
+		formatShortDate(task.deadlineAt) ?? ""
+	]);
+	if (writeFormattedRows(context, filtered.length, headers, rows)) return;
+	if (autoSelected) writeInfo(context, `Auto-selected workspace: ${workspace.name}`);
+	if (limited.length === 0) {
+		writeInfo(context, "No tasks found.");
+		return;
+	}
+	const lines = [];
+	lines.push(`${workspace.name} (${limited.length}/${filtered.length})`);
+	for (const task of limited) {
+		const marker = toTaskMarker(task);
+		const deadline = formatShortDate(task.deadlineAt);
+		const suffix = deadline ? `  due ${deadline}` : "";
+		lines.push(`${marker} ${task.id.slice(0, 8)}  ${task.title}${suffix}`);
+	}
+	for (const line of lines) writeInfo(context, line);
+}
+async function runTaskShow(context, taskRef, options, workspaceOverride) {
+	const task = await resolveTaskReference(context, {
+		taskRef,
+		commandContext: await resolveCommandContext(context),
+		workspaceRef: workspaceOverride ?? normalizeWorkspaceRef(options.workspace)
+	});
+	if (context.json) {
+		writeJson({
+			task,
+			state: getTaskState(task),
+			createdAtIso: formatEpochDate(task.createdAt),
+			updatedAtIso: formatEpochDate(task.updatedAt),
+			completedAtIso: formatEpochDate(task.completedAt),
+			archivedAtIso: formatEpochDate(task.archivedAt),
+			deadlineAtIso: formatEpochDate(task.deadlineAt)
+		});
+		return;
+	}
+	writeSuccess(context, task.title);
+	writeInfo(context, `id: ${task.id}`);
+	writeInfo(context, `state: ${getTaskState(task)}`);
+	writeInfo(context, `workspaceId: ${task.workspaceId}`);
+	writeInfo(context, `start: ${task.start}`);
+	writeInfo(context, `startBucket: ${task.startBucket}`);
+	writeInfo(context, `deadline: ${formatEpochDate(task.deadlineAt) ?? "(none)"}`);
+	if (task.projectId) writeInfo(context, `projectId: ${task.projectId}`);
+	if (task.teamId) writeInfo(context, `teamId: ${task.teamId}`);
+	if (task.assigneeId) writeInfo(context, `assigneeId: ${task.assigneeId}`);
+	if (task.description) writeInfo(context, `notes: ${task.description}`);
+}
+async function runTaskAdd(context, title, options, workspaceOverride) {
+	const commandContext = await resolveCommandContext(context);
+	const userId = requireUserId(commandContext.resolvedToken);
+	const normalizedTitle = title.trim();
+	if (normalizedTitle.length === 0) throw new Error("Task title cannot be empty.");
+	const { workspace, autoSelected } = await resolveWorkspace(context, {
+		token: commandContext.token,
+		apiBaseUrl: commandContext.apiBaseUrl,
+		workspaceRef: workspaceOverride ?? normalizeWorkspaceRef(options.workspace),
+		storedWorkspaceId: commandContext.localContext.workspaceId
+	});
+	const [projectId, teamId] = await Promise.all([options.project ? loadProjectsByWorkspace(context, {
+		baseUrl: commandContext.apiBaseUrl,
+		token: commandContext.token,
+		workspaceId: workspace.id
+	}).then((projects) => resolveEntityId(projects, options.project, "Project")) : Promise.resolve(null), options.team ? loadTeamsByWorkspace(context, {
+		baseUrl: commandContext.apiBaseUrl,
+		token: commandContext.token,
+		workspaceId: workspace.id
+	}).then((teams) => resolveEntityId(teams, options.team, "Team")) : Promise.resolve(null)]);
+	const taskId = randomUUID();
+	const now = Date.now();
+	const view = parseTaskView(options.when);
+	const startFields = buildTaskStartFields(view);
+	await mutateTask(context, {
+		baseUrl: commandContext.apiBaseUrl,
+		token: commandContext.token,
+		request: {
+			batchId: randomUUID(),
+			transactions: [{
+				clientTxId: randomUUID(),
+				clientId: commandContext.localContext.clientId,
+				modelName: "Task",
+				modelId: taskId,
+				action: "INSERT",
+				payload: {
+					title: normalizedTitle,
+					description: options.notes?.trim() || null,
+					creatorId: userId,
+					workspaceId: workspace.id,
+					createdAt: now,
+					updatedAt: now,
+					sortOrder: 0,
+					todaySortOrder: 0,
+					completedAt: null,
+					archivedAt: null,
+					deadlineAt: parseDeadline(options.deadline),
+					projectId,
+					teamId,
+					...startFields
+				}
+			}]
+		}
+	});
+	if (context.json) {
+		writeJson({
+			created: true,
+			id: taskId,
+			workspaceId: workspace.id,
+			workspaceName: workspace.name,
+			autoSelected,
+			view,
+			projectId,
+			teamId
+		});
+		return;
+	}
+	if (autoSelected) writeInfo(context, `Auto-selected workspace: ${workspace.name}`);
+	writeSuccess(context, `Added task: ${normalizedTitle}`);
+	writeInfo(context, `id: ${taskId}`);
+}
+async function runTaskMutation(context, taskRef, payload) {
+	const commandContext = await resolveCommandContext(context);
+	const task = await resolveTaskReference(context, {
+		taskRef,
+		commandContext,
+		workspaceRef: payload.workspaceRef
+	});
+	await mutateTask(context, {
+		baseUrl: commandContext.apiBaseUrl,
+		token: commandContext.token,
+		request: {
+			batchId: randomUUID(),
+			transactions: [{
+				clientTxId: randomUUID(),
+				clientId: commandContext.localContext.clientId,
+				modelName: "Task",
+				modelId: task.id,
+				action: payload.action,
+				payload: payload.data
+			}]
+		}
+	});
+	if (context.json) {
+		writeJson({
+			ok: true,
+			id: task.id,
+			action: payload.action
+		});
+		return;
+	}
+	writeSuccess(context, `${payload.successMessage}: ${task.id}`);
+}
+function resolveEntityId(entities, ref, label) {
+	const trimmed = ref.trim();
+	const lower = trimmed.toLowerCase();
+	const found = entities.find((e) => e.id === trimmed || e.key.toLowerCase() === lower || e.id.startsWith(trimmed));
+	if (!found) throw new Error(`${label} "${ref}" not found.`);
+	return found.id;
+}
+async function resolveProjectId(context, commandContext, projectRef, workspaceRef) {
+	const { workspace } = await resolveWorkspace(context, {
+		token: commandContext.token,
+		apiBaseUrl: commandContext.apiBaseUrl,
+		workspaceRef,
+		storedWorkspaceId: commandContext.localContext.workspaceId
+	});
+	return resolveEntityId(await loadProjectsByWorkspace(context, {
+		baseUrl: commandContext.apiBaseUrl,
+		token: commandContext.token,
+		workspaceId: workspace.id
+	}), projectRef, "Project");
+}
+async function resolveTeamId(context, commandContext, teamRef, workspaceRef) {
+	const { workspace } = await resolveWorkspace(context, {
+		token: commandContext.token,
+		apiBaseUrl: commandContext.apiBaseUrl,
+		workspaceRef,
+		storedWorkspaceId: commandContext.localContext.workspaceId
+	});
+	return resolveEntityId(await loadTeamsByWorkspace(context, {
+		baseUrl: commandContext.apiBaseUrl,
+		token: commandContext.token,
+		workspaceId: workspace.id
+	}), teamRef, "Team");
+}
+function validateTaskEditOptions(options) {
+	if (options.clearNotes && typeof options.notes === "string") throw new Error("Use either --notes or --clear-notes, not both.");
+	if (options.clearDeadline && typeof options.deadline === "string") throw new Error("Use either --deadline or --clear-deadline, not both.");
+	if (options.clearProject && typeof options.project === "string") throw new Error("Use either --project or --clear-project, not both.");
+	if (options.clearTeam && typeof options.team === "string") throw new Error("Use either --team or --clear-team, not both.");
+}
+function applyScalarEdits(updates, options) {
+	if (typeof options.title === "string") {
+		const title = options.title.trim();
+		if (title.length === 0) throw new Error("Task title cannot be empty.");
+		updates.title = title;
+	}
+	if (options.clearNotes) updates.description = null;
+	else if (typeof options.notes === "string") {
+		const notes = options.notes.trim();
+		updates.description = notes.length > 0 ? notes : null;
+	}
+	if (typeof options.when === "string") Object.assign(updates, buildTaskStartFields(parseTaskView(options.when)));
+	if (options.clearDeadline) updates.deadlineAt = null;
+	else if (typeof options.deadline === "string") updates.deadlineAt = parseDeadline(options.deadline);
+}
+async function runTaskEdit(context, taskRef, options, workspaceOverride) {
+	validateTaskEditOptions(options);
+	const updates = {};
+	applyScalarEdits(updates, options);
+	const wsRef = workspaceOverride ?? normalizeWorkspaceRef(options.workspace);
+	const commandContext = await resolveCommandContext(context);
+	if (options.clearProject) updates.projectId = null;
+	else if (typeof options.project === "string") updates.projectId = await resolveProjectId(context, commandContext, options.project, wsRef);
+	if (options.clearTeam) updates.teamId = null;
+	else if (typeof options.team === "string") updates.teamId = await resolveTeamId(context, commandContext, options.team, wsRef);
+	if (Object.keys(updates).length === 0) throw new Error("No updates provided. Use --title, --notes, --clear-notes, --when, --deadline, --clear-deadline, --project, --clear-project, --team, or --clear-team.");
+	updates.updatedAt = Date.now();
+	await runTaskMutation(context, taskRef, {
+		workspaceRef: wsRef,
+		action: "UPDATE",
+		data: updates,
+		successMessage: "Updated"
+	});
+}
+async function runTaskRead(context, taskRef, options, workspaceOverride) {
+	const task = await resolveTaskReference(context, {
+		taskRef,
+		commandContext: await resolveCommandContext(context),
+		workspaceRef: workspaceOverride ?? normalizeWorkspaceRef(options.workspace)
+	});
+	if (context.json) {
+		writeJson({
+			id: task.id,
+			description: task.description
+		});
+		return;
+	}
+	writeInfo(context, task.description ?? "(empty)");
+}
+async function runTaskAppend(context, taskRef, text, options, workspaceOverride) {
+	const task = await resolveTaskReference(context, {
+		taskRef,
+		commandContext: await resolveCommandContext(context),
+		workspaceRef: workspaceOverride ?? normalizeWorkspaceRef(options.workspace)
+	});
+	const newDesc = `${task.description ?? ""}\n${text.trim()}`;
+	await runTaskMutation(context, task.id, {
+		workspaceRef: workspaceOverride ?? normalizeWorkspaceRef(options.workspace),
+		action: "UPDATE",
+		data: {
+			description: newDesc,
+			updatedAt: Date.now()
+		},
+		successMessage: "Appended"
+	});
+}
+async function runTaskPrepend(context, taskRef, text, options, workspaceOverride) {
+	const task = await resolveTaskReference(context, {
+		taskRef,
+		commandContext: await resolveCommandContext(context),
+		workspaceRef: workspaceOverride ?? normalizeWorkspaceRef(options.workspace)
+	});
+	const existing = task.description ?? "";
+	const newDesc = existing.length > 0 ? `${text.trim()}\n${existing}` : text.trim();
+	await runTaskMutation(context, task.id, {
+		workspaceRef: workspaceOverride ?? normalizeWorkspaceRef(options.workspace),
+		action: "UPDATE",
+		data: {
+			description: newDesc,
+			updatedAt: Date.now()
+		},
+		successMessage: "Prepended"
+	});
+}
+async function runTaskRandom(context, options, workspaceOverride) {
+	const commandContext = await resolveCommandContext(context);
+	const requestedState = options.state ? parseTaskState(options.state) : "open";
+	const { workspace, autoSelected } = await resolveWorkspace(context, {
+		token: commandContext.token,
+		apiBaseUrl: commandContext.apiBaseUrl,
+		workspaceRef: workspaceOverride ?? normalizeWorkspaceRef(options.workspace),
+		storedWorkspaceId: commandContext.localContext.workspaceId
+	});
+	const filtered = filterTasks(await loadTasksByWorkspace(context, {
+		baseUrl: commandContext.apiBaseUrl,
+		token: commandContext.token,
+		workspaceId: workspace.id
+	}), {
+		state: requestedState,
+		search: null
+	});
+	if (filtered.length === 0) {
+		if (context.json) {
+			writeJson({ task: null });
+			return;
+		}
+		writeInfo(context, "No tasks found.");
+		return;
+	}
+	const task = filtered[Math.floor(Math.random() * filtered.length)];
+	if (!task) throw new Error("Failed to pick a random task.");
+	if (context.json) {
+		writeJson({
+			task,
+			state: getTaskState(task),
+			createdAtIso: formatEpochDate(task.createdAt),
+			updatedAtIso: formatEpochDate(task.updatedAt),
+			completedAtIso: formatEpochDate(task.completedAt),
+			archivedAtIso: formatEpochDate(task.archivedAt),
+			deadlineAtIso: formatEpochDate(task.deadlineAt)
+		});
+		return;
+	}
+	if (autoSelected) writeInfo(context, `Auto-selected workspace: ${workspace.name}`);
+	writeSuccess(context, task.title);
+	writeInfo(context, `id: ${task.id}`);
+	writeInfo(context, `state: ${getTaskState(task)}`);
+	writeInfo(context, `workspaceId: ${task.workspaceId}`);
+	writeInfo(context, `start: ${task.start}`);
+	writeInfo(context, `startBucket: ${task.startBucket}`);
+	writeInfo(context, `deadline: ${formatEpochDate(task.deadlineAt) ?? "(none)"}`);
+	if (task.description) writeInfo(context, `notes: ${task.description}`);
+}
+async function resolveChecklistItemReference(context, commandContext, taskId, itemRef) {
+	const trimmed = itemRef.trim();
+	if (!trimmed) throw new Error("Checklist item id is required.");
+	const items = await loadChecklistItemsByTask(context, {
+		baseUrl: commandContext.apiBaseUrl,
+		token: commandContext.token,
+		taskId
+	});
+	const exact = items.find((item) => item.id === trimmed);
+	if (exact) return exact;
+	const matches = items.filter((item) => item.id.startsWith(trimmed));
+	if (matches.length === 0) throw new Error(`Checklist item "${trimmed}" not found.`);
+	if (matches.length === 1) {
+		const [match] = matches;
+		if (!match) throw new Error(`Checklist item "${trimmed}" not found.`);
+		return match;
+	}
+	throw new Error(`Checklist item prefix "${trimmed}" is ambiguous (${matches.length} matches). Use the full id.`);
+}
+async function runChecklistList(context, taskId, workspaceOption) {
+	const commandContext = await resolveCommandContext(context);
+	const task = await resolveTaskReference(context, {
+		taskRef: taskId,
+		commandContext,
+		workspaceRef: workspaceOption?.trim() ?? null
+	});
+	const sorted = [...await loadChecklistItemsByTask(context, {
+		baseUrl: commandContext.apiBaseUrl,
+		token: commandContext.token,
+		taskId: task.id
+	})].sort((a, b) => a.sortOrder - b.sortOrder);
+	if (context.json) {
+		writeJson({
+			taskId: task.id,
+			items: sorted
+		});
+		return;
+	}
+	if (sorted.length === 0) {
+		writeInfo(context, "No checklist items.");
+		return;
+	}
+	writeInfo(context, `Checklist for: ${task.title}`);
+	for (const item of sorted) writeInfo(context, `${item.completedAt !== null ? "[x]" : "[ ]"} ${item.id.slice(0, 8)}  ${item.title}`);
+}
+function registerTaskCommands(program, workspaceOverride) {
+	const task = program.command("task").alias("tasks").description("Manage tasks").addHelpText("after", `
+Examples:
+  donebear task
+  donebear task add "Write launch post" --when today
+  donebear task list --state done --limit 50
+  donebear task edit 8f2c1a --deadline 2026-03-05
+`).action(async (_options, command) => {
+		const context = contextFromCommand(command);
+		await runWithErrorHandling(context, async () => {
+			await runTaskList(context, {
+				state: "open",
+				limit: DEFAULT_TASK_LIST_LIMIT
+			}, workspaceOverride);
+		});
+	});
+	task.command("list").alias("ls").description("List tasks").option("-w, --workspace <workspace>", "Workspace id, slug, or exact name").option("-s, --state <state>", "open|done|archived|all", "open").option("-n, --limit <count>", "Maximum number of tasks", (value) => parsePositiveInteger(value, "Limit"), DEFAULT_TASK_LIST_LIMIT).option("-q, --search <query>", "Filter by title or notes").action(async (options, command) => {
+		const context = contextFromCommand(command);
+		await runWithErrorHandling(context, async () => {
+			await runTaskList(context, options, workspaceOverride);
+		});
+	});
+	task.command("show").description("Show task details").argument("<id>", "Task id or unique prefix").option("-w, --workspace <workspace>", "Workspace id, slug, or exact name").action(async (taskId, options, command) => {
+		const context = contextFromCommand(command);
+		await runWithErrorHandling(context, async () => {
+			await runTaskShow(context, taskId, options, workspaceOverride);
+		});
+	});
+	task.command("read").description("Print the description (notes) of a task").argument("<id>", "Task id or unique prefix").option("-w, --workspace <workspace>", "Workspace id, slug, or exact name").action(async (taskId, options, command) => {
+		const context = contextFromCommand(command);
+		await runWithErrorHandling(context, async () => {
+			await runTaskRead(context, taskId, options, workspaceOverride);
+		});
+	});
+	task.command("append").description("Append text to a task's description").argument("<id>", "Task id or unique prefix").argument("<text>", "Text to append").option("-w, --workspace <workspace>", "Workspace id, slug, or exact name").action(async (taskId, text, options, command) => {
+		const context = contextFromCommand(command);
+		await runWithErrorHandling(context, async () => {
+			await runTaskAppend(context, taskId, text, options, workspaceOverride);
+		});
+	});
+	task.command("prepend").description("Prepend text to a task's description").argument("<id>", "Task id or unique prefix").argument("<text>", "Text to prepend").option("-w, --workspace <workspace>", "Workspace id, slug, or exact name").action(async (taskId, text, options, command) => {
+		const context = contextFromCommand(command);
+		await runWithErrorHandling(context, async () => {
+			await runTaskPrepend(context, taskId, text, options, workspaceOverride);
+		});
+	});
+	task.command("random").description("Show a random task").option("-w, --workspace <workspace>", "Workspace id, slug, or exact name").option("-s, --state <state>", "open|done|archived|all", "open").action(async (options, command) => {
+		const context = contextFromCommand(command);
+		await runWithErrorHandling(context, async () => {
+			await runTaskRandom(context, options, workspaceOverride);
+		});
+	});
+	task.command("add").alias("create").description("Create a task").argument("<title>", "Task title").option("-w, --workspace <workspace>", "Workspace id, slug, or exact name").option("-n, --notes <text>", "Task notes").option("--when <view>", "inbox|anytime|today|upcoming|someday", "inbox").option("--deadline <date>", "Deadline (YYYY-MM-DD or ISO datetime)").option("--project <key-or-id>", "Project key or id").option("--team <key-or-id>", "Team key or id").action(async (title, options, command) => {
+		const context = contextFromCommand(command);
+		await runWithErrorHandling(context, async () => {
+			await runTaskAdd(context, title, options, workspaceOverride);
+		});
+	});
+	task.command("edit").description("Update task fields").argument("<id>", "Task id or unique prefix").option("-w, --workspace <workspace>", "Workspace id, slug, or exact name").option("--title <title>", "Replace task title").option("--notes <text>", "Replace task notes (empty string clears)").option("--clear-notes", "Clear task notes").option("--when <view>", "Set view bucket (inbox|anytime|today|upcoming|someday)").option("--deadline <date>", "Set deadline (YYYY-MM-DD or ISO datetime)").option("--clear-deadline", "Clear deadline").option("--project <key-or-id>", "Set project (key or id)").option("--clear-project", "Remove project assignment").option("--team <key-or-id>", "Set team (key or id)").option("--clear-team", "Remove team assignment").action(async (taskId, options, command) => {
+		const context = contextFromCommand(command);
+		await runWithErrorHandling(context, async () => {
+			await runTaskEdit(context, taskId, options, workspaceOverride);
+		});
+	});
+	task.command("done").alias("complete").description("Mark a task as completed").argument("<id>", "Task id or unique prefix").option("-w, --workspace <workspace>", "Workspace id, slug, or exact name").action(async (taskId, options, command) => {
+		const context = contextFromCommand(command);
+		await runWithErrorHandling(context, async () => {
+			const now = Date.now();
+			await runTaskMutation(context, taskId, {
+				workspaceRef: workspaceOverride ?? normalizeWorkspaceRef(options.workspace),
+				action: "UPDATE",
+				data: {
+					completedAt: now,
+					updatedAt: now
+				},
+				successMessage: "Marked done"
+			});
+		});
+	});
+	task.command("reopen").alias("undo").description("Reopen a completed task").argument("<id>", "Task id or unique prefix").option("-w, --workspace <workspace>", "Workspace id, slug, or exact name").action(async (taskId, options, command) => {
+		const context = contextFromCommand(command);
+		await runWithErrorHandling(context, async () => {
+			await runTaskMutation(context, taskId, {
+				workspaceRef: workspaceOverride ?? normalizeWorkspaceRef(options.workspace),
+				action: "UPDATE",
+				data: {
+					completedAt: null,
+					updatedAt: Date.now()
+				},
+				successMessage: "Reopened"
+			});
+		});
+	});
+	task.command("archive").description("Archive a task").argument("<id>", "Task id or unique prefix").option("-w, --workspace <workspace>", "Workspace id, slug, or exact name").action(async (taskId, options, command) => {
+		const context = contextFromCommand(command);
+		await runWithErrorHandling(context, async () => {
+			await runTaskMutation(context, taskId, {
+				workspaceRef: workspaceOverride ?? normalizeWorkspaceRef(options.workspace),
+				action: "ARCHIVE",
+				data: { archivedAt: Date.now() },
+				successMessage: "Archived"
+			});
+		});
+	});
+	task.command("unarchive").alias("restore").description("Unarchive a task").argument("<id>", "Task id or unique prefix").option("-w, --workspace <workspace>", "Workspace id, slug, or exact name").action(async (taskId, options, command) => {
+		const context = contextFromCommand(command);
+		await runWithErrorHandling(context, async () => {
+			await runTaskMutation(context, taskId, {
+				workspaceRef: workspaceOverride ?? normalizeWorkspaceRef(options.workspace),
+				action: "UNARCHIVE",
+				data: {},
+				successMessage: "Unarchived"
+			});
+		});
+	});
+	const checklist = task.command("checklist").alias("cl").description("Manage task checklist items").argument("<task-id>", "Task id or prefix").option("-w, --workspace <workspace>", "Workspace id, slug, or exact name").action(async (taskId, options, command) => {
+		const context = contextFromCommand(command);
+		await runWithErrorHandling(context, async () => {
+			await runChecklistList(context, taskId, options.workspace);
+		});
+	});
+	checklist.command("add").description("Add a checklist item").argument("<task-id>", "Task id or prefix").argument("<title>", "Item title").option("-w, --workspace <workspace>", "Workspace id, slug, or exact name").action(async (taskId, title, options, command) => {
+		const context = contextFromCommand(command);
+		await runWithErrorHandling(context, async () => {
+			const commandContext = await resolveCommandContext(context);
+			const task = await resolveTaskReference(context, {
+				taskRef: taskId,
+				commandContext,
+				workspaceRef: options.workspace?.trim() ?? null
+			});
+			const itemId = randomUUID();
+			const now = Date.now();
+			await mutateModel(context, {
+				baseUrl: commandContext.apiBaseUrl,
+				token: commandContext.token,
+				request: {
+					batchId: randomUUID(),
+					transactions: [{
+						clientTxId: randomUUID(),
+						clientId: commandContext.localContext.clientId,
+						modelName: "TaskChecklistItem",
+						modelId: itemId,
+						action: "INSERT",
+						payload: {
+							title: title.trim(),
+							taskId: task.id,
+							workspaceId: task.workspaceId,
+							sortOrder: now,
+							completedAt: null,
+							createdAt: now,
+							updatedAt: now
+						}
+					}]
+				}
+			});
+			if (context.json) {
+				writeJson({
+					created: true,
+					id: itemId
+				});
+				return;
+			}
+			writeSuccess(context, `Added: ${title.trim()}`);
+		});
+	});
+	checklist.command("done").description("Mark a checklist item as complete").argument("<task-id>", "Task id or prefix").argument("<item-id>", "Checklist item id or prefix").option("-w, --workspace <workspace>", "Workspace id, slug, or exact name").action(async (taskId, itemId, options, command) => {
+		const context = contextFromCommand(command);
+		await runWithErrorHandling(context, async () => {
+			const commandContext = await resolveCommandContext(context);
+			const item = await resolveChecklistItemReference(context, commandContext, (await resolveTaskReference(context, {
+				taskRef: taskId,
+				commandContext,
+				workspaceRef: options.workspace?.trim() ?? null
+			})).id, itemId);
+			const now = Date.now();
+			await mutateModel(context, {
+				baseUrl: commandContext.apiBaseUrl,
+				token: commandContext.token,
+				request: {
+					batchId: randomUUID(),
+					transactions: [{
+						clientTxId: randomUUID(),
+						clientId: commandContext.localContext.clientId,
+						modelName: "TaskChecklistItem",
+						modelId: item.id,
+						action: "UPDATE",
+						payload: {
+							completedAt: now,
+							updatedAt: now
+						}
+					}]
+				}
+			});
+			if (context.json) {
+				writeJson({
+					ok: true,
+					id: item.id
+				});
+				return;
+			}
+			writeSuccess(context, `Marked done: ${item.title}`);
+		});
+	});
+	checklist.command("reopen").description("Reopen a completed checklist item").argument("<task-id>", "Task id or prefix").argument("<item-id>", "Checklist item id or prefix").option("-w, --workspace <workspace>", "Workspace id, slug, or exact name").action(async (taskId, itemId, options, command) => {
+		const context = contextFromCommand(command);
+		await runWithErrorHandling(context, async () => {
+			const commandContext = await resolveCommandContext(context);
+			const item = await resolveChecklistItemReference(context, commandContext, (await resolveTaskReference(context, {
+				taskRef: taskId,
+				commandContext,
+				workspaceRef: options.workspace?.trim() ?? null
+			})).id, itemId);
+			const now = Date.now();
+			await mutateModel(context, {
+				baseUrl: commandContext.apiBaseUrl,
+				token: commandContext.token,
+				request: {
+					batchId: randomUUID(),
+					transactions: [{
+						clientTxId: randomUUID(),
+						clientId: commandContext.localContext.clientId,
+						modelName: "TaskChecklistItem",
+						modelId: item.id,
+						action: "UPDATE",
+						payload: {
+							completedAt: null,
+							updatedAt: now
+						}
+					}]
+				}
+			});
+			if (context.json) {
+				writeJson({
+					ok: true,
+					id: item.id
+				});
+				return;
+			}
+			writeSuccess(context, `Reopened: ${item.title}`);
+		});
+	});
+	checklist.command("edit").description("Edit a checklist item title").argument("<task-id>", "Task id or prefix").argument("<item-id>", "Checklist item id or prefix").requiredOption("--title <title>", "New item title").option("-w, --workspace <workspace>", "Workspace id, slug, or exact name").action(async (taskId, itemId, options, command) => {
+		const context = contextFromCommand(command);
+		await runWithErrorHandling(context, async () => {
+			const newTitle = options.title.trim();
+			if (newTitle.length === 0) throw new Error("Checklist item title cannot be empty.");
+			const commandContext = await resolveCommandContext(context);
+			const item = await resolveChecklistItemReference(context, commandContext, (await resolveTaskReference(context, {
+				taskRef: taskId,
+				commandContext,
+				workspaceRef: options.workspace?.trim() ?? null
+			})).id, itemId);
+			const now = Date.now();
+			await mutateModel(context, {
+				baseUrl: commandContext.apiBaseUrl,
+				token: commandContext.token,
+				request: {
+					batchId: randomUUID(),
+					transactions: [{
+						clientTxId: randomUUID(),
+						clientId: commandContext.localContext.clientId,
+						modelName: "TaskChecklistItem",
+						modelId: item.id,
+						action: "UPDATE",
+						payload: {
+							title: newTitle,
+							updatedAt: now
+						}
+					}]
+				}
+			});
+			if (context.json) {
+				writeJson({
+					ok: true,
+					id: item.id
+				});
+				return;
+			}
+			writeSuccess(context, `Updated: ${newTitle}`);
+		});
+	});
+	checklist.command("remove").alias("rm").description("Remove a checklist item").argument("<task-id>", "Task id or prefix").argument("<item-id>", "Checklist item id or prefix").option("-w, --workspace <workspace>", "Workspace id, slug, or exact name").action(async (taskId, itemId, options, command) => {
+		const context = contextFromCommand(command);
+		await runWithErrorHandling(context, async () => {
+			const commandContext = await resolveCommandContext(context);
+			const item = await resolveChecklistItemReference(context, commandContext, (await resolveTaskReference(context, {
+				taskRef: taskId,
+				commandContext,
+				workspaceRef: options.workspace?.trim() ?? null
+			})).id, itemId);
+			await mutateModel(context, {
+				baseUrl: commandContext.apiBaseUrl,
+				token: commandContext.token,
+				request: {
+					batchId: randomUUID(),
+					transactions: [{
+						clientTxId: randomUUID(),
+						clientId: commandContext.localContext.clientId,
+						modelName: "TaskChecklistItem",
+						modelId: item.id,
+						action: "ARCHIVE",
+						payload: {}
+					}]
+				}
+			});
+			if (context.json) {
+				writeJson({
+					removed: true,
+					id: item.id
+				});
+				return;
+			}
+			writeSuccess(context, `Removed: ${item.title}`);
+		});
+	});
+}
+
+//#endregion
+//#region src/commands/search.ts
+const DEFAULT_SEARCH_LIMIT = 20;
+async function runSearch(context, query, options, workspaceOverride) {
+	const commandContext = await resolveCommandContext(context);
+	const requestedState = parseTaskState(options.state);
+	const trimmedQuery = query.trim();
+	if (trimmedQuery.length === 0) throw new Error("Search query cannot be empty.");
+	const { workspace, autoSelected } = await resolveWorkspace(context, {
+		token: commandContext.token,
+		apiBaseUrl: commandContext.apiBaseUrl,
+		workspaceRef: workspaceOverride ?? normalizeWorkspaceRef(options.workspace),
+		storedWorkspaceId: commandContext.localContext.workspaceId
+	});
+	const filtered = filterTasks(await loadTasksByWorkspace(context, {
+		baseUrl: commandContext.apiBaseUrl,
+		token: commandContext.token,
+		workspaceId: workspace.id
+	}), {
+		state: requestedState,
+		search: trimmedQuery
+	});
+	const limited = filtered.slice(0, options.limit);
+	if (context.json) {
+		writeJson({
+			workspace,
+			autoSelected,
+			query: trimmedQuery,
+			state: requestedState,
+			total: filtered.length,
+			count: limited.length,
+			tasks: limited
+		});
+		return;
+	}
+	const headers = [
+		"id",
+		"title",
+		"state",
+		"deadline"
+	];
+	const rows = limited.map((task) => [
+		task.id,
+		task.title,
+		getTaskState(task),
+		formatShortDate(task.deadlineAt) ?? ""
+	]);
+	if (writeFormattedRows(context, filtered.length, headers, rows)) return;
+	if (autoSelected) writeInfo(context, `Auto-selected workspace: ${workspace.name}`);
+	if (limited.length === 0) {
+		writeInfo(context, `No tasks found matching "${trimmedQuery}".`);
+		return;
+	}
+	const lines = [];
+	lines.push(`${workspace.name} — "${trimmedQuery}" (${limited.length}/${filtered.length})`);
+	for (const task of limited) {
+		const marker = toTaskMarker(task);
+		const deadline = formatShortDate(task.deadlineAt);
+		const suffix = deadline ? `  due ${deadline}` : "";
+		lines.push(`${marker} ${task.id.slice(0, 8)}  ${task.title}${suffix}`);
+	}
+	for (const line of lines) writeInfo(context, line);
+	if (context.copy) copyToClipboard(lines.join("\n"));
+}
+function registerSearchCommand(program, workspaceOverride) {
+	program.command("search").description("Search tasks by title or notes").argument("<query>", "Search query").option("-w, --workspace <workspace>", "Workspace id, slug, or exact name").option("-s, --state <state>", "open|done|archived|all", "all").option("-n, --limit <count>", "Maximum number of results", (value) => parsePositiveInteger(value, "Limit"), DEFAULT_SEARCH_LIMIT).addHelpText("after", `
+Examples:
+  donebear search "meeting"
+  donebear search "launch" --state open
+  donebear search "Q1" --format csv --copy
+  donebear search "review" --total
+`).action(async (query, options, command) => {
+		const context = contextFromCommand(command);
+		await runWithErrorHandling(context, async () => {
+			await runSearch(context, query, options, workspaceOverride);
+		});
+	});
+}
+
+//#endregion
+//#region src/commands/team.ts
+function findTeam(ref, teams) {
+	const normalized = ref.trim().toLowerCase();
+	for (const team of teams) {
+		if (team.id === ref) return team;
+		if (team.key.toLowerCase() === normalized) return team;
+		if (team.id.startsWith(ref)) return team;
+	}
+	return null;
+}
+async function runTeamList(context, workspaceOverride, options) {
+	const commandContext = await resolveCommandContext(context);
+	const { workspace } = await resolveWorkspace(context, {
+		token: commandContext.token,
+		apiBaseUrl: commandContext.apiBaseUrl,
+		workspaceRef: workspaceOverride ?? normalizeWorkspaceRef(options.workspace),
+		storedWorkspaceId: commandContext.localContext.workspaceId
+	});
+	const teams = await loadTeamsByWorkspace(context, {
+		baseUrl: commandContext.apiBaseUrl,
+		token: commandContext.token,
+		workspaceId: workspace.id
+	});
+	if (context.json) {
+		writeJson({
+			workspace,
+			teams
+		});
+		return;
+	}
+	const headers = [
+		"id",
+		"key",
+		"name"
+	];
+	const rows = teams.map((t) => [
+		t.id,
+		t.key,
+		t.name
+	]);
+	if (writeFormattedRows(context, teams.length, headers, rows)) return;
+	if (teams.length === 0) {
+		writeInfo(context, "No teams found.");
+		return;
+	}
+	writeInfo(context, `Teams in ${workspace.name}:`);
+	for (const team of teams) writeInfo(context, `${team.id.slice(0, 8)}  [${team.key}]  ${team.name}`);
+}
+async function runTeamShow(context, teamRef, workspaceOverride, options) {
+	const commandContext = await resolveCommandContext(context);
+	const { workspace } = await resolveWorkspace(context, {
+		token: commandContext.token,
+		apiBaseUrl: commandContext.apiBaseUrl,
+		workspaceRef: workspaceOverride ?? normalizeWorkspaceRef(options.workspace),
+		storedWorkspaceId: commandContext.localContext.workspaceId
+	});
+	const teams = await loadTeamsByWorkspace(context, {
+		baseUrl: commandContext.apiBaseUrl,
+		token: commandContext.token,
+		workspaceId: workspace.id
+	});
+	const team = findTeam(teamRef.trim(), teams);
+	if (!team) throw new Error(`Team "${teamRef}" not found. Run \`donebear team list\`.`);
+	if (context.json) {
+		writeJson({
+			workspace,
+			team
+		});
+		return;
+	}
+	writeSuccess(context, team.name);
+	writeInfo(context, `id: ${team.id}`);
+	writeInfo(context, `key: ${team.key}`);
+	writeInfo(context, `name: ${team.name}`);
+	writeInfo(context, `description: ${team.description ?? "(none)"}`);
+	writeInfo(context, `workspaceId: ${team.workspaceId ?? "(none)"}`);
+}
+function registerTeamCommands(program, workspaceOverride) {
+	const team = program.command("team").alias("teams").description("Manage teams").addHelpText("after", `
+Examples:
+  donebear team
+  donebear team list
+  donebear team show ENG
+  donebear team list --format csv
+`).action(async (_options, command) => {
+		const context = contextFromCommand(command);
+		await runWithErrorHandling(context, async () => {
+			await runTeamList(context, workspaceOverride, {});
+		});
+	});
+	team.command("list").alias("ls").description("List teams in the current or specified workspace").option("-w, --workspace <workspace>", "Workspace id, slug, or exact name").action(async (options, command) => {
+		const context = contextFromCommand(command);
+		await runWithErrorHandling(context, async () => {
+			await runTeamList(context, workspaceOverride, options);
+		});
+	});
+	team.command("show").description("Show team details").argument("<id-or-key>", "Team id, key, or id prefix").option("-w, --workspace <workspace>", "Workspace id, slug, or exact name").action(async (teamRef, options, command) => {
+		const context = contextFromCommand(command);
+		await runWithErrorHandling(context, async () => {
+			await runTeamShow(context, teamRef, workspaceOverride, options);
+		});
+	});
+}
+
+//#endregion
+//#region src/commands/today.ts
+const DEFAULT_TODAY_LIMIT = 20;
+async function runToday(context, options, workspaceOverride) {
+	const commandContext = await resolveCommandContext(context);
+	const { workspace, autoSelected } = await resolveWorkspace(context, {
+		token: commandContext.token,
+		apiBaseUrl: commandContext.apiBaseUrl,
+		workspaceRef: workspaceOverride ?? normalizeWorkspaceRef(options.workspace),
+		storedWorkspaceId: commandContext.localContext.workspaceId
+	});
+	const todayTasks = (await loadTasksByWorkspace(context, {
+		baseUrl: commandContext.apiBaseUrl,
+		token: commandContext.token,
+		workspaceId: workspace.id
+	})).filter((task) => task.todayIndexReferenceDate !== null && task.completedAt === null && task.archivedAt === null);
+	const limited = todayTasks.slice(0, options.limit);
+	if (context.json) {
+		writeJson({
+			workspace,
+			autoSelected,
+			total: todayTasks.length,
+			count: limited.length,
+			tasks: limited
+		});
+		return;
+	}
+	const headers = [
+		"id",
+		"title",
+		"state",
+		"deadline"
+	];
+	const rows = limited.map((task) => [
+		task.id,
+		task.title,
+		getTaskState(task),
+		formatShortDate(task.deadlineAt) ?? ""
+	]);
+	if (writeFormattedRows(context, todayTasks.length, headers, rows)) return;
+	if (autoSelected) writeInfo(context, `Auto-selected workspace: ${workspace.name}`);
+	if (limited.length === 0) {
+		writeInfo(context, "No tasks for today.");
+		return;
+	}
+	const lines = [];
+	lines.push(`${workspace.name} — Today (${limited.length}/${todayTasks.length})`);
+	for (const task of limited) {
+		const marker = toTaskMarker(task);
+		const deadline = formatShortDate(task.deadlineAt);
+		const suffix = deadline ? `  due ${deadline}` : "";
+		lines.push(`${marker} ${task.id.slice(0, 8)}  ${task.title}${suffix}`);
+	}
+	for (const line of lines) writeInfo(context, line);
+	if (context.copy) copyToClipboard(lines.join("\n"));
+}
+function registerTodayCommand(program, workspaceOverride) {
+	program.command("today").description("List today's tasks").option("-w, --workspace <workspace>", "Workspace id, slug, or exact name").option("-n, --limit <count>", "Maximum number of tasks", (value) => parsePositiveInteger(value, "Limit"), DEFAULT_TODAY_LIMIT).addHelpText("after", `
+Examples:
+  donebear today
+  donebear today --limit 10
+  donebear today --format csv
+  donebear today --total
+`).action(async (options, command) => {
+		const context = contextFromCommand(command);
+		await runWithErrorHandling(context, async () => {
+			await runToday(context, options, workspaceOverride);
+		});
+	});
+}
+
+//#endregion
+//#region src/commands/whoami.ts
+async function runWhoAmI(context) {
+	const config = resolveSupabaseConfig();
+	const resolvedToken = await resolveAuthToken(context, config);
+	if (!resolvedToken) {
+		process.exitCode = EXIT_CODES.AUTH_REQUIRED;
+		if (context.json) {
+			writeJson({
+				ok: false,
+				error: {
+					message: "Not authenticated",
+					exitCode: EXIT_CODES.AUTH_REQUIRED
+				}
+			});
+			return;
+		}
+		writeInfo(context, "Not authenticated.");
+		writeInfo(context, "Run `donebear auth login`.");
+		return;
+	}
+	const user = await getSupabaseUser(config, resolvedToken.token);
+	if (context.json) {
+		writeJson({
+			ok: true,
+			user: {
+				id: user.id,
+				email: user.email ?? null
+			},
+			source: resolvedToken.source
+		});
+		return;
+	}
+	writeSuccess(context, "Authenticated user:");
+	writeInfo(context, `id: ${user.id}`);
+	writeInfo(context, `email: ${user.email ?? "(none)"}`);
+	writeInfo(context, `source: ${resolvedToken.source}`);
+}
+function registerWhoAmICommand(program) {
+	program.command("whoami").alias("me").description("Show the current authenticated user").action(async (_options, command) => {
+		const context = contextFromCommand(command);
+		await runWithErrorHandling(context, async () => {
+			await runWhoAmI(context);
+		});
+	});
+}
+
+//#endregion
+//#region src/commands/workspace.ts
+function findWorkspace(workspaceRef, workspaces) {
+	const normalizedReference = workspaceRef.trim().toLowerCase();
+	return workspaces.find((workspace) => {
+		if (workspace.id === workspaceRef) return true;
+		if (workspace.urlKey?.toLowerCase() === normalizedReference) return true;
+		return workspace.name.toLowerCase() === normalizedReference;
+	});
+}
+function writeCurrentWorkspaceNotAvailable(context, message) {
+	if (context.json) {
+		writeJson({ workspace: null });
+		return;
+	}
+	writeInfo(context, message);
+	writeInfo(context, "Run `donebear workspace use <id-or-slug>`.");
+}
+async function runWorkspaceList(context) {
+	const commandContext = await resolveCommandContext(context);
+	const workspaces = await listWorkspaces(context, {
+		baseUrl: commandContext.apiBaseUrl,
+		token: commandContext.token
+	});
+	if (context.json) {
+		writeJson({
+			workspaces,
+			currentWorkspaceId: commandContext.localContext.workspaceId
+		});
+		return;
+	}
+	if (workspaces.length === 0) {
+		writeInfo(context, "No workspaces found.");
+		return;
+	}
+	writeInfo(context, "Workspaces:");
+	for (const workspace of workspaces) writeInfo(context, `${workspace.id === commandContext.localContext.workspaceId ? "*" : " "} ${workspace.id}  ${workspace.name}${workspace.urlKey ? ` (${workspace.urlKey})` : ""}  role=${workspace.role}`);
+}
+async function runWorkspaceCurrent(context) {
+	const commandContext = await resolveCommandContext(context);
+	if (!commandContext.localContext.workspaceId) {
+		writeCurrentWorkspaceNotAvailable(context, "No default workspace selected.");
+		return;
+	}
+	const workspace = (await listWorkspaces(context, {
+		baseUrl: commandContext.apiBaseUrl,
+		token: commandContext.token
+	})).find((item) => item.id === commandContext.localContext.workspaceId);
+	if (!workspace) {
+		writeCurrentWorkspaceNotAvailable(context, "Saved workspace is no longer accessible.");
+		return;
+	}
+	if (context.json) {
+		writeJson({ workspace });
+		return;
+	}
+	writeSuccess(context, `Current workspace: ${workspace.name}`);
+	writeInfo(context, `id: ${workspace.id}`);
+	writeInfo(context, `slug: ${workspace.urlKey ?? "(none)"}`);
+	writeInfo(context, `role: ${workspace.role}`);
+}
+async function runWorkspaceUse(context, reference) {
+	const commandContext = await resolveCommandContext(context);
+	const selected = findWorkspace(reference, await listWorkspaces(context, {
+		baseUrl: commandContext.apiBaseUrl,
+		token: commandContext.token
+	}));
+	if (!selected) throw new Error(`Workspace "${reference}" not found. Run \`donebear workspace list\`.`);
+	await setCurrentWorkspace(selected.id);
+	if (context.json) {
+		writeJson({
+			workspace: selected,
+			selected: true
+		});
+		return;
+	}
+	writeSuccess(context, `Selected workspace: ${selected.name}`);
+	writeInfo(context, `id: ${selected.id}`);
+}
+async function runWorkspaceClear(context) {
+	await setCurrentWorkspace(null);
+	if (context.json) {
+		writeJson({
+			cleared: true,
+			workspace: null
+		});
+		return;
+	}
+	writeSuccess(context, "Cleared current workspace.");
+}
+async function runWorkspaceCreate(context, name, options) {
+	const commandContext = await resolveCommandContext(context);
+	const slug = (options.slug ?? toWorkspaceUrlKey(name)).trim();
+	if (!isValidWorkspaceUrlKey(slug)) throw new Error("Workspace slug must be lowercase alphanumeric with hyphens and at least 3 characters");
+	const workspace = await createWorkspace(context, {
+		baseUrl: commandContext.apiBaseUrl,
+		token: commandContext.token,
+		body: {
+			name,
+			urlKey: slug,
+			logoUrl: options.logoUrl
+		}
+	});
+	if (options.use) await setCurrentWorkspace(workspace.id);
+	if (context.json) {
+		writeJson({
+			workspace,
+			selected: options.use
+		});
+		return;
+	}
+	writeSuccess(context, `Created workspace: ${workspace.name}`);
+	writeInfo(context, `id: ${workspace.id}`);
+	writeInfo(context, `slug: ${workspace.urlKey ?? slug}`);
+	if (options.use) writeInfo(context, "Set as current workspace.");
+}
+async function runWorkspaceJoin(context, code, options) {
+	const commandContext = await resolveCommandContext(context);
+	const trimmedCode = code.trim();
+	if (!trimmedCode) throw new Error("Invitation code is required.");
+	const joined = await joinWorkspace(context, {
+		baseUrl: commandContext.apiBaseUrl,
+		token: commandContext.token,
+		code: trimmedCode
+	});
+	if (options.use) await setCurrentWorkspace(joined.workspace.id);
+	if (context.json) {
+		writeJson({
+			workspace: joined.workspace,
+			role: joined.role,
+			selected: options.use
+		});
+		return;
+	}
+	writeSuccess(context, `Joined workspace: ${joined.workspace.name}`);
+	writeInfo(context, `id: ${joined.workspace.id}`);
+	writeInfo(context, `role: ${joined.role}`);
+	if (options.use) writeInfo(context, "Set as current workspace.");
+}
+async function runWorkspaceMembers(context, workspaceRefArg, workspaceOverride, options) {
+	const commandContext = await resolveCommandContext(context);
+	const { workspace } = await resolveWorkspace(context, {
+		token: commandContext.token,
+		apiBaseUrl: commandContext.apiBaseUrl,
+		workspaceRef: workspaceOverride ?? workspaceRefArg ?? null,
+		storedWorkspaceId: commandContext.localContext.workspaceId
+	});
+	const members = await listWorkspaceMembers(context, {
+		baseUrl: commandContext.apiBaseUrl,
+		token: commandContext.token,
+		workspaceId: workspace.id
+	});
+	if (context.json) {
+		writeJson({
+			workspace,
+			members
+		});
+		return;
+	}
+	if (context.total) {
+		writeTotal(context, members.length);
+		return;
+	}
+	const format = options.format?.trim().toLowerCase() ?? context.format;
+	if (format === "csv") {
+		writeCsv([
+			"userId",
+			"name",
+			"email",
+			"role"
+		], members.map((m) => [
+			m.userId,
+			m.user.name ?? "",
+			m.user.email ?? "",
+			m.role
+		]));
+		return;
+	}
+	if (format === "tsv") {
+		writeTsv([
+			"userId",
+			"name",
+			"email",
+			"role"
+		], members.map((m) => [
+			m.userId,
+			m.user.name ?? "",
+			m.user.email ?? "",
+			m.role
+		]));
+		return;
+	}
+	if (members.length === 0) {
+		writeInfo(context, "No members found.");
+		return;
+	}
+	writeInfo(context, `Members of ${workspace.name}:`);
+	for (const member of members) writeInfo(context, `${member.userId}  ${member.user.name ?? "(no name)"}  ${member.user.email ?? "(no email)"}  ${member.role}`);
+}
+async function runWorkspaceInvitations(context, workspaceRefArg, workspaceOverride) {
+	const commandContext = await resolveCommandContext(context);
+	const { workspace } = await resolveWorkspace(context, {
+		token: commandContext.token,
+		apiBaseUrl: commandContext.apiBaseUrl,
+		workspaceRef: workspaceOverride ?? workspaceRefArg ?? null,
+		storedWorkspaceId: commandContext.localContext.workspaceId
+	});
+	const invitations = await listWorkspaceInvitations(context, {
+		baseUrl: commandContext.apiBaseUrl,
+		token: commandContext.token,
+		workspaceId: workspace.id
+	});
+	if (context.json) {
+		writeJson({
+			workspace,
+			invitations
+		});
+		return;
+	}
+	if (invitations.length === 0) {
+		writeInfo(context, "No invitations found.");
+		return;
+	}
+	writeInfo(context, `Invitations for ${workspace.name}:`);
+	for (const invitation of invitations) {
+		const used = invitation.usedAt ? "yes" : "no";
+		writeInfo(context, `${invitation.id.slice(0, 8)}  ${invitation.email ?? "(open)"}  ${invitation.role}  expires=${invitation.expiresAt}  used=${used}`);
+	}
+}
+async function runWorkspaceInvite(context, workspaceRefArg, workspaceOverride, options) {
+	const commandContext = await resolveCommandContext(context);
+	const { workspace } = await resolveWorkspace(context, {
+		token: commandContext.token,
+		apiBaseUrl: commandContext.apiBaseUrl,
+		workspaceRef: workspaceOverride ?? workspaceRefArg ?? null,
+		storedWorkspaceId: commandContext.localContext.workspaceId
+	});
+	const invitation = await createWorkspaceInvitation(context, {
+		baseUrl: commandContext.apiBaseUrl,
+		token: commandContext.token,
+		workspaceId: workspace.id,
+		email: options.email,
+		role: options.role ?? "member"
+	});
+	if (context.json) {
+		writeJson({
+			workspace,
+			invitation
+		});
+		return;
+	}
+	writeSuccess(context, `Invitation created for ${workspace.name}`);
+	writeInfo(context, `code: ${invitation.code}`);
+	writeInfo(context, `role: ${invitation.role}`);
+	writeInfo(context, `expires: ${invitation.expiresAt}`);
+	if (invitation.email) writeInfo(context, `email: ${invitation.email}`);
+	const link = `${commandContext.apiBaseUrl}/invite/${invitation.code}`;
+	writeInfo(context, `link: ${link}`);
+	if (context.copy) {
+		if (copyToClipboard(link)) writeInfo(context, "Link copied to clipboard.");
+	}
+}
+function registerWorkspaceCommands(program, workspaceOverride) {
+	const workspace = program.command("workspace").alias("ws").description("Manage workspaces").addHelpText("after", `
+Examples:
+  donebear workspace
+  donebear workspace use personal
+  donebear workspace create "Personal" --slug personal
+  donebear workspace join ABCD2345
+  donebear workspace members
+  donebear workspace invitations
+  donebear workspace invite --email user@example.com --role member
+`).action(async (_options, command) => {
+		const context = contextFromCommand(command);
+		await runWithErrorHandling(context, async () => {
+			await runWorkspaceList(context);
+		});
+	});
+	workspace.command("list").alias("ls").description("List workspaces available to the current user").action(async (_options, command) => {
+		const context = contextFromCommand(command);
+		await runWithErrorHandling(context, async () => {
+			await runWorkspaceList(context);
+		});
+	});
+	workspace.command("current").description("Show the current default workspace").action(async (_options, command) => {
+		const context = contextFromCommand(command);
+		await runWithErrorHandling(context, async () => {
+			await runWorkspaceCurrent(context);
+		});
+	});
+	workspace.command("use").description("Set the default workspace").argument("<workspace>", "Workspace id, slug, or exact name").action(async (workspaceRef, _options, command) => {
+		const context = contextFromCommand(command);
+		await runWithErrorHandling(context, async () => {
+			await runWorkspaceUse(context, workspaceRef);
+		});
+	});
+	workspace.command("clear").description("Clear the default workspace").action(async (_options, command) => {
+		const context = contextFromCommand(command);
+		await runWithErrorHandling(context, async () => {
+			await runWorkspaceClear(context);
+		});
+	});
+	workspace.command("create").description("Create a workspace").argument("<name>", "Workspace display name").option("--slug <slug>", "Workspace urlKey slug").option("--logo-url <url>", "Workspace logo URL").option("--no-use", "Do not set as current workspace").action(async (name, options, command) => {
+		const context = contextFromCommand(command);
+		await runWithErrorHandling(context, async () => {
+			await runWorkspaceCreate(context, name, options);
+		});
+	});
+	workspace.command("join").description("Join a workspace with an invitation code").argument("<code>", "Invitation code").option("--no-use", "Do not set joined workspace as current").action(async (code, options, command) => {
+		const context = contextFromCommand(command);
+		await runWithErrorHandling(context, async () => {
+			await runWorkspaceJoin(context, code, options);
+		});
+	});
+	workspace.command("members").description("List members of the current or specified workspace").argument("[workspace]", "Workspace id, slug, or exact name").option("--format <format>", "Output format: text|json|csv|tsv").option("--total", "Print member count only").action(async (workspaceRef, options, command) => {
+		const context = contextFromCommand(command);
+		await runWithErrorHandling(context, async () => {
+			await runWorkspaceMembers(context, workspaceRef, workspaceOverride, options);
+		});
+	});
+	workspace.command("invitations").alias("invites").description("List pending invitations for the current or specified workspace").argument("[workspace]", "Workspace id, slug, or exact name").action(async (workspaceRef, _options, command) => {
+		const context = contextFromCommand(command);
+		await runWithErrorHandling(context, async () => {
+			await runWorkspaceInvitations(context, workspaceRef, workspaceOverride);
+		});
+	});
+	workspace.command("invite").description("Create an invitation for the current or specified workspace").argument("[workspace]", "Workspace id, slug, or exact name").option("--email <email>", "Email address to invite").option("--role <role>", "Role for the invitee: member|admin", "member").action(async (workspaceRef, options, command) => {
+		const context = contextFromCommand(command);
+		await runWithErrorHandling(context, async () => {
+			await runWorkspaceInvite(context, workspaceRef, workspaceOverride, options);
+		});
+	});
+}
+
+//#endregion
+//#region src/cli.ts
+const packageManifest = createRequire(import.meta.url)("../package.json");
+const WORKSPACE_PREFIX_REGEX = /^workspace=(.+)$/i;
+function extractWorkspaceTarget(argv) {
+	const processedArgv = [...argv];
+	const firstArg = processedArgv[2];
+	if (firstArg) {
+		const match = WORKSPACE_PREFIX_REGEX.exec(firstArg);
+		if (match?.[1]) {
+			processedArgv.splice(2, 1);
+			return {
+				processedArgv,
+				workspaceOverride: match[1].trim()
+			};
+		}
+	}
+	return {
+		processedArgv,
+		workspaceOverride: null
+	};
+}
+async function main() {
+	loadCliEnvironmentFiles();
+	const { processedArgv, workspaceOverride } = extractWorkspaceTarget(process.argv);
+	const program = new Command();
+	program.name(CLI_NAME).description("Done Bear CLI for auth, workspace, and task workflows").version(packageManifest.version).showHelpAfterError().showSuggestionAfterError().option("--json", "Output machine-readable JSON").option("--format <format>", "Output format: text|json|csv|tsv", "text").option("--copy", "Copy output to clipboard").option("--total", "Print count only").option("--token <token>", "Use an explicit token (overrides DONEBEAR_TOKEN)").option("--api-url <url>", "Manage API base URL (overrides DONEBEAR_API_URL)").option("--debug", "Enable debug logs", process.env[DONEBEAR_DEBUG_ENV] === "1").option("--no-color", "Disable color output").addHelpText("after", `
+Quick start:
+  donebear auth login
+  donebear workspace
+  donebear task add "Plan week" --when today
+  donebear task
+  donebear today
+  donebear search "meeting"
+  donebear project
+  donebear label
+
+Workspace targeting:
+  donebear workspace=myorg task list
+
+Use --json for scripting, --format csv|tsv for export, --total for counts.
+`);
+	registerAuthCommands(program);
+	registerWorkspaceCommands(program, workspaceOverride);
+	registerTaskCommands(program, workspaceOverride);
+	registerProjectCommands(program, workspaceOverride);
+	registerLabelCommands(program, workspaceOverride);
+	registerTeamCommands(program, workspaceOverride);
+	registerTodayCommand(program, workspaceOverride);
+	registerSearchCommand(program, workspaceOverride);
+	registerHistoryCommand(program, workspaceOverride);
+	registerWhoAmICommand(program);
+	const hasUserArgs = processedArgv.length <= 2;
+	const isTTY = process.stdin.isTTY === true;
+	if (hasUserArgs && isTTY) {
+		await runInteractiveMode(contextFromArgv(processedArgv), program);
+		return;
+	}
+	await program.parseAsync(processedArgv);
+}
+await runWithErrorHandling(contextFromArgv(process.argv), main);
+
+//#endregion
+export {  };
+//# sourceMappingURL=cli.mjs.map