pawmode 1.0.1 → 1.2.0

package/dist/scheduler-DAmd0GzB.js

@@ -0,0 +1,888 @@
+import { listInstalledSkills } from "./skills-CMqq9k1-.js";
+import * as p from "@clack/prompts";
+import * as os$2 from "node:os";
+import * as os$1 from "node:os";
+import chalk from "chalk";
+import { execSync } from "node:child_process";
+import * as fs$2 from "node:fs";
+import * as fs$1 from "node:fs";
+import * as path$2 from "node:path";
+import * as path$1 from "node:path";
+import { Bot } from "grammy";
+import { hydrate } from "@grammyjs/hydrate";
+import { query } from "@anthropic-ai/claude-agent-sdk";
+import * as crypto from "node:crypto";
+
+//#region src/core/branding.ts
+const accent = chalk.hex("#b4783c");
+const subtle = chalk.hex("#8a5a2a");
+const dim = chalk.dim;
+const bold = chalk.bold;
+const pawClr = chalk.hex("#b4783c");
+const PAW_ART = [
+	"                                            ▃▅",
+	"                                           ▁██▁               ▄█▁",
+	"                                       ▁▁▂▆▇██▃               ▅█▆",
+	"                                      ▅▆█▇▆▄███▆▂         ▁▂▆▇██▇▅▁",
+	"                                    ▁▃█▆▁   ▄███▄▁       ▆▇▇▅▄▄███▇▃▁",
+	"                                   ▁▃█▄     ▁████▂     ▁▅█▃   ▁▃████▂",
+	"                                   ▄█▇▁     ▂████▄▁   ▁▃█▇     ▁████▅▂",
+	"                                   ▅█▆      ▂█████▁   ▄█▇▁      ▂████▃",
+	"                        ▂▁         ▆█▆      ▂█████▁   ▄█▇      ▁▂████▂",
+	"                      ▁▅█▂         ▆█▆▁   ▁▃▇████▆▁   ▄█▇     ▂▄█████▂",
+	"                      ▁██▄▂        ▂██▇▆▃▄▇██████     ▄██▄▇▇▃▃▆█████▁",
+	"                     ▂█████▇▅▂▁    ▁▄▇█████████▆▂     ▃▇████████████▁        ▁▂▁",
+	"                    ▄█▇▃  ▁███▆▁     ▁▃▆▇▇▇▇▃▄▂        ▂▆█████████▅         ▁▇█▂",
+	"                   ▃▆▄▁    ▅███▆▃                         ▄▄▅▅▅▅▂▁       ▂▄▃▄██▂",
+	"                   ▆█▄     ▃████▄           ▁▄▄██████▄▃▃▂            ▁▂▆▇▇▆████▇▁",
+	"                   ▆█▄      ▂████▄        ▂▅▇▇▅▅▁▃▅█▇████▆▂         ▅▇▇▅▄▁ ▂▆████▂",
+	"                   ▇█▄      ▅████▄        ▇█▄     ▁▃▇▆████▇▂      ▂▃█▇▃ ▁    ▃███▂",
+	"                   ▇██▅   ▂▆████▄▁       ▆█▄▁ ▁    ▅▄▅█████▅      ▆█▆▂      ▃▆███▁",
+	"                   ▁████████████▃       ▂▇▆▂         ▄█████▆     ▃██▂      ▂▆███▆",
+	"                    ▃█████████▅▂        ██▂          ▄█████▆     ▅██▁     ▁████▇",
+	"                      ▂▄▄▄▄▄▄          ▇█▃▁         ▁▅█████▅     ▃██▄▇▆▁▁▄▇████▆",
+	"                                   ▁▁▁▇█▂▁ ▁        ▄██████▆▂     ▇███████████▅▁",
+	"                               ▁▁▄▅▆██▅▂  ▁▁        ▄███████▄      ▄▅██████▆▅▂",
+	"                              ▄██▆▅▄▂▁  ▁           ▃▆██████▇▄▂      ▁▁▁▁▁▁▁",
+	"                            ▂██▄▁▁                   ▁▄▅██████▇▆▂▁",
+	"                           ▃▇▇▂    ▁▁                  ▁ ▃▇██████▇▃▁",
+	"                          ▁▄█▆   ▁                        ▁▆█▇█████▆▂",
+	"                          ▄██▇                             ▃▅███████▅▁",
+	"                          ▄██▇▁       ▂▂▂▁▁▂▆▇▇▇▇▇▃▁       ▄▆▄▂▇█████▃",
+	"                          ▃▇██▇▃   ▁▂▆▆██▆▇█████████▆▄▁▁  ▁▁▁▄▇██████▃",
+	"                           ▄█████▆▆▇███████████████████▆▃▁ ▁▄▇███████▃",
+	"                           ▁▅█████████████████████████████▅█████████▄▁",
+	"                            ▁▂▆█████████████████████████████████████▂",
+	"                              ▁▂▆▆▆▆▆▆▃▂▂▂▂▂▂▂▂▂▂▂▂▂▅▆███████████▇▆▁",
+	"                                                      ▃▃▇▇▇▇▇▇▇▃▃"
+];
+const PAW_ROWS = PAW_ART.length;
+function sleep(ms) {
+	return new Promise((r) => setTimeout(r, ms));
+}
+const TITLE_3D = [
+	"█▀▀█░█▀▀▄░█▀▀▀░█▄ █░█▀▀▄░▄▀▀▄░█   █░",
+	"█  █░█▀▀ ░█▀▀ ░█ ▀█░█▀▀ ░█▀▀█░█ █ █░",
+	"▀▀▀▀░▀   ░▀▀▀▀░▀  ▀░▀   ░▀  ▀░ ▀ ▀ ░",
+	"░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░"
+];
+const TITLE_MARGIN = "                                ";
+function renderTitle() {
+	const lines = TITLE_3D.map((artLine) => {
+		let result = "";
+		let buf = "";
+		let bufType = "space";
+		const flush = () => {
+			if (!buf) return;
+			if (bufType === "main") result += pawClr(buf);
+			else if (bufType === "depth") result += subtle(buf);
+			else result += buf;
+			buf = "";
+		};
+		for (const ch of artLine) {
+			const type = ch === "░" ? "depth" : ch === " " ? "space" : "main";
+			if (type !== bufType) {
+				flush();
+				bufType = type;
+			}
+			buf += ch;
+		}
+		flush();
+		const margin = artLine === TITLE_3D[TITLE_3D.length - 1] ? TITLE_MARGIN.slice(1) : TITLE_MARGIN;
+		return margin + result;
+	});
+	const sub = dim("                              Personal Assistant Wizard for Claude Code");
+	return lines.join("\n") + "\n" + sub;
+}
+const MOOD_HEX = {
+	wave: "#b4783c",
+	think: "#b4783c",
+	happy: "#b4783c",
+	work: "#9a6832",
+	done: "#c88a48",
+	warn: "#dca03c"
+};
+function pawColor(mood) {
+	return chalk.hex(MOOD_HEX[mood]);
+}
+function renderPaw(color) {
+	return PAW_ART.map((line) => color(line)).join("\n");
+}
+/**
+* Banner: brown paw + ASCII title.
+*/
+async function showBanner() {
+	console.log(renderPaw(pawClr));
+	console.log("");
+	console.log(renderTitle());
+	console.log("");
+}
+/**
+* Show paw between wizard steps — mood-colored, brief flash, then clears.
+*/
+async function pawStep(mood, message) {
+	const color = pawColor(mood);
+	process.stdout.write(renderPaw(color) + "\n");
+	if (message) console.log(`  ${accent(message)}`);
+	await sleep(300);
+	const lines = PAW_ROWS + (message ? 1 : 0);
+	process.stdout.write(`\x1B[${lines}A\x1B[J`);
+}
+/**
+* Inline pulse indicator for quick transitions.
+*/
+async function pawPulse(mood, message) {
+	if (!message) return;
+	const line = `  ${accent("◉")} ${subtle(message)}`;
+	for (let i = 0; i < 3; i++) {
+		if (i > 0) process.stdout.write("\x1B[1A");
+		const s = i % 2 === 0 ? bold : dim;
+		process.stdout.write(`\x1B[2K${s(line)}\n`);
+		await sleep(80);
+	}
+	process.stdout.write(`\x1B[1A\x1B[2K${line}\n`);
+}
+/**
+* Mini one-liner.
+*/
+function showMini() {
+	console.log(accent("  ◉ openpaw") + dim(" — Personal Assistant Wizard for Claude Code"));
+}
+/**
+* Puppy disclaimer about --dangerously-skip-permissions.
+*/
+function showPuppyDisclaimer() {
+	console.log("");
+	console.log(pawClr("     /\\_/\\"));
+	console.log(pawClr("    ( o.o )") + `   ${bold("WOOF! One important sniff...")}`);
+	console.log(pawClr("     > ^ <"));
+	console.log("");
+	console.log(`  ${accent("You're about to let Claude off the leash!")}`);
+	console.log(dim("  (--dangerously-skip-permissions)"));
+	console.log("");
+	console.log("  This lets Claude run commands without asking each time.");
+	console.log("  It's how your assistant actually gets things done —");
+	console.log("  checking email, playing music, managing files.");
+	console.log("");
+	console.log(dim("  OpenPaw's safety hooks still block the dangerous stuff"));
+	console.log(dim("  (mass deletes, credential leaks, etc)."));
+	console.log("");
+	console.log(dim("  You can always run 'claude' normally without this."));
+	console.log("");
+}
+
+//#endregion
+//#region src/core/telegram.ts
+const CONFIG_DIR$1 = path$2.join(os$2.homedir(), ".config", "openpaw");
+const CONFIG_PATH = path$2.join(CONFIG_DIR$1, "telegram.json");
+function writeTelegramConfig(config) {
+	fs$2.mkdirSync(CONFIG_DIR$1, { recursive: true });
+	fs$2.writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2));
+	fs$2.chmodSync(CONFIG_PATH, 384);
+}
+function readTelegramConfig() {
+	try {
+		const raw = fs$2.readFileSync(CONFIG_PATH, "utf-8");
+		return JSON.parse(raw);
+	} catch {
+		return null;
+	}
+}
+function telegramConfigExists() {
+	return fs$2.existsSync(CONFIG_PATH);
+}
+async function telegramQuestionnaire() {
+	p.log.info(dim("Let's set up your Telegram bot! You'll need:"));
+	p.log.info(`  ${accent("1.")} Message ${bold("@BotFather")} on Telegram → /newbot`);
+	p.log.info(`  ${accent("2.")} Message ${bold("@userinfobot")} to get your user ID`);
+	console.log("");
+	const botToken = await p.text({
+		message: "Paste your bot token (from @BotFather):",
+		placeholder: "123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11",
+		validate: (v) => {
+			if (v.length === 0) return "Bot token is required";
+			if (!v.includes(":")) return "That doesn't look like a bot token (should contain ':')";
+			return void 0;
+		}
+	});
+	if (p.isCancel(botToken)) return null;
+	const userId = await p.text({
+		message: "Your Telegram user ID (from @userinfobot):",
+		placeholder: "123456789",
+		validate: (v) => {
+			if (v.length === 0) return "User ID is required";
+			if (!/^\d+$/.test(v)) return "User ID should be a number";
+			return void 0;
+		}
+	});
+	if (p.isCancel(userId)) return null;
+	return {
+		botToken,
+		allowedUserIds: [userId.trim()],
+		workspaceDir: os$2.homedir(),
+		model: "sonnet",
+		skills: []
+	};
+}
+const sessions = new Map();
+const MODEL_MAP$1 = {
+	sonnet: "claude-sonnet-4-5-20250514",
+	opus: "claude-opus-4-6",
+	haiku: "claude-haiku-4-5-20251001"
+};
+function getModelId(shortName) {
+	return MODEL_MAP$1[shortName] || MODEL_MAP$1.sonnet;
+}
+async function startTelegramBot(config) {
+	const bot = new Bot(config.botToken);
+	bot.use(hydrate());
+	const allowedIds = new Set(config.allowedUserIds.map(Number));
+	let currentModel = config.model || "sonnet";
+	bot.use(async (ctx, next) => {
+		if (!ctx.from || !allowedIds.has(ctx.from.id)) {
+			await ctx.reply("Woof! I don't know you. Unauthorized. 🐾");
+			return;
+		}
+		await next();
+	});
+	const installedSkills = listInstalledSkills();
+	const skillCommands = installedSkills.filter((id) => id !== "core" && id !== "memory").map((id) => ({
+		command: id,
+		description: `Use the ${id} skill`
+	}));
+	const allCommands = [
+		{
+			command: "start",
+			description: "Start the bot"
+		},
+		{
+			command: "model",
+			description: "Switch Claude model (sonnet/opus/haiku)"
+		},
+		{
+			command: "skills",
+			description: "List installed skills"
+		},
+		{
+			command: "stop",
+			description: "Cancel current operation"
+		},
+		{
+			command: "clear",
+			description: "Reset conversation"
+		},
+		...skillCommands
+	];
+	try {
+		await bot.api.setMyCommands(allCommands);
+	} catch {}
+	bot.command("start", async (ctx) => {
+		const skills = installedSkills.filter((id) => id !== "core" && id !== "memory");
+		await ctx.reply(`*PAW MODE active* 🐾
+
+I'm your personal assistant, powered by OpenPaw.
+Model: \`${currentModel}\`\nSkills: ${skills.length > 0 ? skills.map((s) => `/${s}`).join(", ") : "none"}\n\nJust send me a message or use a /command!`, { parse_mode: "Markdown" });
+	});
+	bot.command("model", async (ctx) => {
+		const arg = ctx.match?.trim().toLowerCase();
+		if (!arg || ![
+			"sonnet",
+			"opus",
+			"haiku"
+		].includes(arg)) {
+			await ctx.reply(`Current model: \`${currentModel}\`\n\nSwitch with:\n/model sonnet\n/model opus\n/model haiku`, { parse_mode: "Markdown" });
+			return;
+		}
+		currentModel = arg;
+		config.model = arg;
+		writeTelegramConfig(config);
+		await ctx.reply(`Model switched to \`${currentModel}\` 🐾`, { parse_mode: "Markdown" });
+	});
+	bot.command("skills", async (ctx) => {
+		const skills = installedSkills.filter((id) => id !== "core" && id !== "memory");
+		if (skills.length === 0) {
+			await ctx.reply("No skills installed yet. Run `openpaw setup` first! 🐾");
+			return;
+		}
+		const list = skills.map((s) => `• /${s}`).join("\n");
+		await ctx.reply(`*Installed skills:*\n\n${list}`, { parse_mode: "Markdown" });
+	});
+	bot.command("stop", async (ctx) => {
+		const userId = ctx.from.id;
+		const session = sessions.get(userId);
+		if (session?.controller) {
+			session.controller.abort();
+			sessions.delete(userId);
+			await ctx.reply("Operation cancelled. 🐾");
+		} else await ctx.reply("Nothing running right now. 🐾");
+	});
+	bot.command("clear", async (ctx) => {
+		const userId = ctx.from.id;
+		sessions.delete(userId);
+		await ctx.reply("Conversation cleared! Fresh start. 🐾");
+	});
+	for (const skillId of installedSkills) {
+		if (skillId === "core" || skillId === "memory") continue;
+		bot.command(skillId, async (ctx) => {
+			const args = ctx.match || "";
+			const prompt = args ? `Use the c-${skillId} skill: ${args}` : `What can the c-${skillId} skill do? Give a brief overview.`;
+			await handleClaudeMessage(ctx, prompt, currentModel, config);
+		});
+	}
+	bot.on("message:text", async (ctx) => {
+		await handleClaudeMessage(ctx, ctx.msg.text, currentModel, config);
+	});
+	bot.catch((err) => {
+		console.error("Bot error:", err.message || err);
+	});
+	process.on("SIGINT", () => {
+		console.log("\nShutting down gracefully... 🐾");
+		bot.stop();
+		process.exit(0);
+	});
+	process.on("SIGTERM", () => {
+		bot.stop();
+		process.exit(0);
+	});
+	console.log("");
+	console.log(`  🐾 ${bold("OpenPaw Telegram Bridge")}`);
+	console.log(`     Model: ${accent(currentModel)}`);
+	console.log(`     Skills: ${accent(String(installedSkills.length))}`);
+	console.log(`     Workspace: ${dim(config.workspaceDir)}`);
+	console.log(`     Allowed users: ${dim(config.allowedUserIds.join(", "))}`);
+	console.log("");
+	console.log(dim("  Listening for messages... (Ctrl+C to stop)"));
+	console.log("");
+	await bot.start();
+}
+async function handleClaudeMessage(ctx, prompt, model, config) {
+	const userId = ctx.from.id;
+	const existing = sessions.get(userId);
+	if (existing?.controller) existing.controller.abort();
+	const controller = new AbortController();
+	const session = sessions.get(userId) || {};
+	session.controller = controller;
+	sessions.set(userId, session);
+	const statusMsg = await ctx.reply("Thinking... 🐾");
+	let fullText = "";
+	let lastEditTime = 0;
+	const EDIT_INTERVAL = 1500;
+	try {
+		const q = query({
+			prompt,
+			options: {
+				model: getModelId(model),
+				permissionMode: "bypassPermissions",
+				allowDangerouslySkipPermissions: true,
+				cwd: config.workspaceDir,
+				abortController: controller,
+				maxTurns: 25,
+				...session.sessionId ? { resume: session.sessionId } : {}
+			}
+		});
+		for await (const message of q) {
+			if (controller.signal.aborted) break;
+			if (message.type === "system" && "session_id" in message) session.sessionId = message.session_id;
+			if (message.type === "assistant") {
+				const msgContent = message.message;
+				const text = msgContent.content.filter((block) => block.type === "text").map((block) => block.text || "").join("");
+				if (text) {
+					fullText = text;
+					const now = Date.now();
+					if (now - lastEditTime > EDIT_INTERVAL) {
+						lastEditTime = now;
+						const truncated = fullText.length > 4e3 ? `${fullText.slice(0, 4e3)}...` : fullText;
+						try {
+							await statusMsg.editText(truncated);
+						} catch {}
+					}
+				}
+			}
+			if (message.type === "result") {
+				const result = message.result;
+				if (result) fullText = result;
+			}
+		}
+		if (fullText) {
+			const truncated = fullText.length > 4e3 ? `${fullText.slice(0, 4e3)}...` : fullText;
+			try {
+				await statusMsg.editText(truncated);
+			} catch {
+				await ctx.reply(truncated);
+			}
+		} else await statusMsg.editText("Done! (no text output) 🐾");
+	} catch (err) {
+		const errorMsg = err instanceof Error ? err.message : "Unknown error";
+		if (errorMsg.includes("abort") || controller.signal.aborted) return;
+		try {
+			await statusMsg.editText(`Woof, something went wrong: ${errorMsg.slice(0, 200)} 🐾`);
+		} catch {
+			await ctx.reply(`Woof, something went wrong: ${errorMsg.slice(0, 200)} 🐾`);
+		}
+	} finally {
+		session.controller = void 0;
+		sessions.set(userId, session);
+	}
+}
+
+//#endregion
+//#region src/core/scheduler.ts
+const CONFIG_DIR = path$1.join(os$1.homedir(), ".config", "openpaw");
+const SCHEDULE_PATH = path$1.join(CONFIG_DIR, "schedules.json");
+const COST_PATH = path$1.join(CONFIG_DIR, "schedule-costs.json");
+const RESULTS_DIR = path$1.join(CONFIG_DIR, "schedule-results");
+const LOGS_DIR = path$1.join(CONFIG_DIR, "logs");
+const PLIST_DIR = path$1.join(os$1.homedir(), "Library", "LaunchAgents");
+const MODEL_MAP = {
+	sonnet: "claude-sonnet-4-5-20250514",
+	opus: "claude-opus-4-6",
+	haiku: "claude-haiku-4-5-20251001"
+};
+function ensureDirs() {
+	for (const dir of [
+		CONFIG_DIR,
+		RESULTS_DIR,
+		LOGS_DIR
+	]) fs$1.mkdirSync(dir, { recursive: true });
+}
+function readScheduleConfig() {
+	try {
+		const raw = fs$1.readFileSync(SCHEDULE_PATH, "utf-8");
+		return JSON.parse(raw);
+	} catch {
+		return {
+			jobs: [],
+			dailyCostCapUsd: 5,
+			defaultModel: "sonnet"
+		};
+	}
+}
+function writeScheduleConfig(config) {
+	ensureDirs();
+	fs$1.writeFileSync(SCHEDULE_PATH, JSON.stringify(config, null, 2));
+	fs$1.chmodSync(SCHEDULE_PATH, 384);
+}
+function readCostTracker() {
+	try {
+		const raw = fs$1.readFileSync(COST_PATH, "utf-8");
+		return JSON.parse(raw);
+	} catch {
+		return {
+			entries: [],
+			dailyTotals: {}
+		};
+	}
+}
+function writeCostTracker(tracker) {
+	ensureDirs();
+	fs$1.writeFileSync(COST_PATH, JSON.stringify(tracker, null, 2));
+}
+function parseHumanSchedule(input) {
+	const s = input.trim().toLowerCase();
+	if (/^\S+\s+\S+\s+\S+\s+\S+\s+\S+$/.test(s) && /\d/.test(s)) return {
+		cron: s,
+		human: `cron: ${s}`
+	};
+	const parseTime = (t) => {
+		const ampm = t.match(/^(\d{1,2})(?::(\d{2}))?\s*(am|pm)$/);
+		if (ampm) {
+			let hour = Number.parseInt(ampm[1], 10);
+			const minute = ampm[2] ? Number.parseInt(ampm[2], 10) : 0;
+			if (ampm[3] === "pm" && hour !== 12) hour += 12;
+			if (ampm[3] === "am" && hour === 12) hour = 0;
+			return {
+				hour,
+				minute
+			};
+		}
+		const h24 = t.match(/^(\d{1,2}):(\d{2})$/);
+		if (h24) return {
+			hour: Number.parseInt(h24[1], 10),
+			minute: Number.parseInt(h24[2], 10)
+		};
+		return null;
+	};
+	const everyMin = s.match(/^every\s+(\d+)\s+min(?:ute)?s?$/);
+	if (everyMin) {
+		const n = everyMin[1];
+		return {
+			cron: `*/${n} * * * *`,
+			human: `every ${n} minutes`
+		};
+	}
+	const everyHr = s.match(/^every\s+(\d+)\s+hours?$/);
+	if (everyHr) {
+		const n = everyHr[1];
+		return {
+			cron: `0 */${n} * * *`,
+			human: `every ${n} hours`
+		};
+	}
+	const daily = s.match(/^daily\s+(.+)$/);
+	if (daily) {
+		const t = parseTime(daily[1]);
+		if (t) return {
+			cron: `${t.minute} ${t.hour} * * *`,
+			human: `daily at ${daily[1]}`
+		};
+	}
+	const weekdays = s.match(/^weekdays?\s+(.+)$/);
+	if (weekdays) {
+		const t = parseTime(weekdays[1]);
+		if (t) return {
+			cron: `${t.minute} ${t.hour} * * 1-5`,
+			human: `weekdays at ${weekdays[1]}`
+		};
+	}
+	const weekends = s.match(/^weekends?\s+(.+)$/);
+	if (weekends) {
+		const t = parseTime(weekends[1]);
+		if (t) return {
+			cron: `${t.minute} ${t.hour} * * 0,6`,
+			human: `weekends at ${weekends[1]}`
+		};
+	}
+	const dayMap = {
+		sunday: "0",
+		sundays: "0",
+		sun: "0",
+		monday: "1",
+		mondays: "1",
+		mon: "1",
+		tuesday: "2",
+		tuesdays: "2",
+		tue: "2",
+		wednesday: "3",
+		wednesdays: "3",
+		wed: "3",
+		thursday: "4",
+		thursdays: "4",
+		thu: "4",
+		friday: "5",
+		fridays: "5",
+		fri: "5",
+		saturday: "6",
+		saturdays: "6",
+		sat: "6"
+	};
+	const dayMatch = s.match(/^(\w+)\s+(.+)$/);
+	if (dayMatch && dayMap[dayMatch[1]]) {
+		const t = parseTime(dayMatch[2]);
+		if (t) {
+			const dow = dayMap[dayMatch[1]];
+			return {
+				cron: `${t.minute} ${t.hour} * * ${dow}`,
+				human: `${dayMatch[1]}s at ${dayMatch[2]}`
+			};
+		}
+	}
+	return {
+		cron: s,
+		human: s
+	};
+}
+function addJob(opts) {
+	const config = readScheduleConfig();
+	const job = {
+		...opts,
+		id: crypto.randomUUID().slice(0, 8),
+		createdAt: new Date().toISOString()
+	};
+	config.jobs.push(job);
+	writeScheduleConfig(config);
+	return job;
+}
+function removeJob(id) {
+	const config = readScheduleConfig();
+	const idx = config.jobs.findIndex((j) => j.id === id);
+	if (idx === -1) return false;
+	config.jobs.splice(idx, 1);
+	writeScheduleConfig(config);
+	removeSystemJob(id);
+	return true;
+}
+function getJob(id) {
+	return readScheduleConfig().jobs.find((j) => j.id === id);
+}
+function listJobs() {
+	return readScheduleConfig().jobs;
+}
+function toggleJob(id, enabled) {
+	const config = readScheduleConfig();
+	const job = config.jobs.find((j) => j.id === id);
+	if (!job) return false;
+	job.enabled = enabled;
+	writeScheduleConfig(config);
+	if (enabled) installSystemJob(job);
+	else removeSystemJob(id);
+	return true;
+}
+function todayStr() {
+	return new Date().toISOString().slice(0, 10);
+}
+function getTodaysCost() {
+	const tracker = readCostTracker();
+	return tracker.dailyTotals[todayStr()] || 0;
+}
+function canRunWithinBudget(perRunBudget) {
+	const config = readScheduleConfig();
+	return getTodaysCost() + perRunBudget <= config.dailyCostCapUsd;
+}
+function recordCost(jobId, costUsd) {
+	const tracker = readCostTracker();
+	const date = todayStr();
+	tracker.entries.push({
+		date,
+		jobId,
+		costUsd,
+		timestamp: new Date().toISOString()
+	});
+	tracker.dailyTotals[date] = (tracker.dailyTotals[date] || 0) + costUsd;
+	const cutoff = new Date();
+	cutoff.setDate(cutoff.getDate() - 30);
+	const cutoffStr = cutoff.toISOString().slice(0, 10);
+	tracker.entries = tracker.entries.filter((e) => e.date >= cutoffStr);
+	for (const d of Object.keys(tracker.dailyTotals)) if (d < cutoffStr) delete tracker.dailyTotals[d];
+	writeCostTracker(tracker);
+}
+function plistLabel(jobId) {
+	return `com.openpaw.schedule.${jobId}`;
+}
+function plistPath(jobId) {
+	return path$1.join(PLIST_DIR, `${plistLabel(jobId)}.plist`);
+}
+function resolveOpenpawBin() {
+	try {
+		return execSync("which openpaw", { encoding: "utf-8" }).trim();
+	} catch {
+		return "";
+	}
+}
+function generatePlist(job) {
+	const [minute, hour, _dom, _month, dow] = job.schedule.split(" ");
+	const openpawBin = resolveOpenpawBin();
+	let programArgs;
+	if (openpawBin) programArgs = `    <string>${openpawBin}</string>\n    <string>schedule</string>\n    <string>run</string>\n    <string>${job.id}</string>`;
+	else {
+		const npxPath = execSync("which npx", { encoding: "utf-8" }).trim();
+		programArgs = `    <string>${npxPath}</string>\n    <string>openpaw</string>\n    <string>schedule</string>\n    <string>run</string>\n    <string>${job.id}</string>`;
+	}
+	let calendarInterval = "  <dict>\n";
+	if (minute !== "*" && !minute.startsWith("*/")) calendarInterval += `    <key>Minute</key>\n    <integer>${Number.parseInt(minute, 10)}</integer>\n`;
+	if (hour !== "*" && !hour.startsWith("*/")) calendarInterval += `    <key>Hour</key>\n    <integer>${Number.parseInt(hour, 10)}</integer>\n`;
+	if (dow !== "*") {
+		const days = dow.split(",");
+		if (days.length === 1 && !dow.includes("-")) calendarInterval += `    <key>Weekday</key>\n    <integer>${Number.parseInt(dow, 10)}</integer>\n`;
+	}
+	calendarInterval += "  </dict>";
+	const isInterval = minute.startsWith("*/") || hour.startsWith("*/");
+	let intervalOrCalendar;
+	if (isInterval) {
+		let seconds = 0;
+		if (minute.startsWith("*/")) seconds = Number.parseInt(minute.slice(2), 10) * 60;
+		else if (hour.startsWith("*/")) seconds = Number.parseInt(hour.slice(2), 10) * 3600;
+		intervalOrCalendar = `  <key>StartInterval</key>\n  <integer>${seconds}</integer>`;
+	} else if (dow.includes("-")) {
+		const [start, end] = dow.split("-").map(Number);
+		const entries = [];
+		for (let d = start; d <= end; d++) {
+			let entry = "  <dict>\n";
+			if (minute !== "*") entry += `    <key>Minute</key>\n    <integer>${Number.parseInt(minute, 10)}</integer>\n`;
+			if (hour !== "*") entry += `    <key>Hour</key>\n    <integer>${Number.parseInt(hour, 10)}</integer>\n`;
+			entry += `    <key>Weekday</key>\n    <integer>${d}</integer>\n`;
+			entry += "  </dict>";
+			entries.push(entry);
+		}
+		intervalOrCalendar = `  <key>StartCalendarInterval</key>\n  <array>\n${entries.join("\n")}\n  </array>`;
+	} else intervalOrCalendar = `  <key>StartCalendarInterval</key>\n${calendarInterval}`;
+	const logPath = path$1.join(LOGS_DIR, `${job.id}.log`);
+	const errPath = path$1.join(LOGS_DIR, `${job.id}.err`);
+	return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${plistLabel(job.id)}</string>
+  <key>ProgramArguments</key>
+  <array>
+${programArgs}
+  </array>
+${intervalOrCalendar}
+  <key>StandardOutPath</key>
+  <string>${logPath}</string>
+  <key>StandardErrorPath</key>
+  <string>${errPath}</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key>
+    <string>/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:${path$1.join(os$1.homedir(), ".npm-global", "bin")}</string>
+    <key>HOME</key>
+    <string>${os$1.homedir()}</string>
+  </dict>
+</dict>
+</plist>`;
+}
+function installSystemJob(job) {
+	ensureDirs();
+	if (process.platform === "darwin") try {
+		fs$1.mkdirSync(PLIST_DIR, { recursive: true });
+		const plist = generatePlist(job);
+		const p$1 = plistPath(job.id);
+		try {
+			execSync(`launchctl unload "${p$1}" 2>/dev/null`, { stdio: "ignore" });
+		} catch {}
+		fs$1.writeFileSync(p$1, plist);
+		execSync(`launchctl load "${p$1}"`);
+		return true;
+	} catch {
+		return false;
+	}
+	try {
+		const openpawBin = resolveOpenpawBin() || "npx openpaw";
+		const line = `${job.schedule} ${openpawBin} schedule run ${job.id} >> ${LOGS_DIR}/${job.id}.log 2>&1 # openpaw:${job.id}`;
+		const existing = execSync("crontab -l 2>/dev/null || true", { encoding: "utf-8" });
+		const filtered = existing.split("\n").filter((l) => !l.includes(`openpaw:${job.id}`));
+		filtered.push(line);
+		const content = filtered.filter(Boolean).join("\n") + "\n";
+		execSync(`echo '${content.replace(/'/g, "'\\''")}' | crontab -`);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function removeSystemJob(jobId) {
+	if (process.platform === "darwin") {
+		const p$1 = plistPath(jobId);
+		try {
+			execSync(`launchctl unload "${p$1}" 2>/dev/null`, { stdio: "ignore" });
+		} catch {}
+		try {
+			fs$1.unlinkSync(p$1);
+		} catch {}
+		return true;
+	}
+	try {
+		const existing = execSync("crontab -l 2>/dev/null || true", { encoding: "utf-8" });
+		const filtered = existing.split("\n").filter((l) => !l.includes(`openpaw:${jobId}`));
+		const content = filtered.filter(Boolean).join("\n") + "\n";
+		execSync(`echo '${content.replace(/'/g, "'\\''")}' | crontab -`);
+		return true;
+	} catch {
+		return false;
+	}
+}
+async function deliverResult(job, text) {
+	const delivery = job.delivery;
+	const truncated = text.length > 4e3 ? `${text.slice(0, 4e3)}...` : text;
+	if (delivery.type === "telegram") {
+		const tgConfig = readTelegramConfig();
+		if (tgConfig) {
+			const header = `*[${job.name}]*\n\n`;
+			const body = header + truncated;
+			for (const userId of tgConfig.allowedUserIds) try {
+				await fetch(`https://api.telegram.org/bot${tgConfig.botToken}/sendMessage`, {
+					method: "POST",
+					headers: { "Content-Type": "application/json" },
+					body: JSON.stringify({
+						chat_id: userId,
+						text: body,
+						parse_mode: "Markdown"
+					})
+				});
+			} catch {}
+		}
+	}
+	if (delivery.type === "notify") try {
+		const title = `OpenPaw: ${job.name}`;
+		const msg = truncated.slice(0, 200);
+		execSync(`terminal-notifier -title "${title}" -message "${msg.replace(/"/g, "\\\"")}"`, { stdio: "ignore" });
+	} catch {}
+	ensureDirs();
+	const ts = new Date().toISOString().replace(/[:.]/g, "-");
+	const resultPath = path$1.join(RESULTS_DIR, `${job.id}-${ts}.md`);
+	fs$1.writeFileSync(resultPath, `# ${job.name}\n\n**Run:** ${new Date().toISOString()}\n**Model:** ${job.model}\n\n---\n\n${text}`);
+}
+async function runJob(jobId) {
+	const job = getJob(jobId);
+	if (!job) return {
+		success: false,
+		error: `Job ${jobId} not found`
+	};
+	if (!job.enabled) return {
+		success: false,
+		error: `Job ${jobId} is disabled`
+	};
+	if (!canRunWithinBudget(job.maxBudgetUsd)) {
+		const config = readScheduleConfig();
+		const j = config.jobs.find((x) => x.id === jobId);
+		if (j) {
+			j.lastRunAt = new Date().toISOString();
+			j.lastRunResult = "budget_exceeded";
+			writeScheduleConfig(config);
+		}
+		return {
+			success: false,
+			error: "Daily cost cap exceeded"
+		};
+	}
+	let fullText = "";
+	let costUsd = 0;
+	try {
+		const modelId = MODEL_MAP[job.model] || MODEL_MAP.sonnet;
+		const q = query({
+			prompt: job.prompt,
+			options: {
+				model: modelId,
+				permissionMode: "bypassPermissions",
+				allowDangerouslySkipPermissions: true,
+				cwd: os$1.homedir(),
+				maxTurns: 25
+			}
+		});
+		for await (const message of q) {
+			if (message.type === "assistant") {
+				const msgContent = message.message;
+				const text = msgContent.content.filter((block) => block.type === "text").map((block) => block.text || "").join("");
+				if (text) fullText = text;
+			}
+			if (message.type === "result") {
+				const result = message;
+				if (result.result) fullText = result.result;
+				if (result.cost_usd) costUsd = result.cost_usd;
+			}
+		}
+		if (costUsd === 0) costUsd = Math.max(.01, fullText.length / 1e3 * .003);
+		recordCost(jobId, costUsd);
+		await deliverResult(job, fullText || "Job completed with no output.");
+		const config = readScheduleConfig();
+		const j = config.jobs.find((x) => x.id === jobId);
+		if (j) {
+			j.lastRunAt = new Date().toISOString();
+			j.lastRunCostUsd = costUsd;
+			j.lastRunResult = "success";
+			writeScheduleConfig(config);
+		}
+		return {
+			success: true,
+			result: fullText,
+			costUsd
+		};
+	} catch (err) {
+		const errorMsg = err instanceof Error ? err.message : "Unknown error";
+		recordCost(jobId, .01);
+		const config = readScheduleConfig();
+		const j = config.jobs.find((x) => x.id === jobId);
+		if (j) {
+			j.lastRunAt = new Date().toISOString();
+			j.lastRunResult = "error";
+			writeScheduleConfig(config);
+		}
+		return {
+			success: false,
+			error: errorMsg
+		};
+	}
+}
+
+//#endregion
+export { accent, addJob, bold, canRunWithinBudget, dim, getJob, getTodaysCost, installSystemJob, listJobs, parseHumanSchedule, pawPulse, pawStep, readCostTracker, readScheduleConfig, readTelegramConfig, recordCost, removeJob, removeSystemJob, runJob, showBanner, showMini, showPuppyDisclaimer, startTelegramBot, subtle, telegramConfigExists, telegramQuestionnaire, toggleJob, writeScheduleConfig, writeTelegramConfig };