@tekmidian/pai 0.13.4 → 0.14.0

package/dist/{pick-CmG7SCtp.mjs → pick-DxS6p2vI.mjs}

@@ -2670,6 +2670,86 @@ function registerRestoreCommands(program) {
 	});
 }
 
+//#endregion
+//#region src/config/json-store.ts
+/**
+* json-store.ts — read/write JSON config files without destroying them
+*
+* The failure this exists to prevent:
+*
+*     try { return JSON.parse(read(path)); } catch { return {}; }
+*     ... later ...
+*     write(path, JSON.stringify(ourData));
+*
+* An unreadable file becomes an empty object, and the next write makes that
+* permanent. Silently, exit code 0. This shape appeared three times in this
+* repo against three different files, and twice in AIBroker.
+*
+* The distinction that matters is between *missing* and *unreadable*:
+*
+*   missing     — legitimate first run. Start fresh; writing is safe.
+*   unreadable  — the file exists and we could not parse it. Those bytes are
+*                 the only copy of something. Never overwrite them.
+*
+* Collapsing the second into the first is the bug.
+*
+* NOT everything deserves this guard. For a transient buffer — an undelivered
+* message queue, a cache — starting fresh IS the correct recovery, and
+* refusing to write would disable the feature permanently. Use `writeJsonAtomic`
+* alone there: it still prevents a crash from truncating a good file, without
+* blocking recovery. Reserve `readJsonStrict` for data a user cannot rebuild.
+*/
+/**
+* Read a JSON file, distinguishing "absent" from "damaged".
+*
+* @param path   file to read
+* @param label  how to name it to the user, e.g. "~/.claude.json"
+* @throws if the file exists but cannot be read or parsed
+*/
+function readJsonStrict(path, label = path) {
+	if (!existsSync(path)) return {};
+	let raw;
+	try {
+		raw = readFileSync(path, "utf8");
+	} catch (e) {
+		throw new Error(`Could not read ${label}: ${e instanceof Error ? e.message : String(e)}\nRefusing to continue — writing now would replace its contents with ours alone.`);
+	}
+	try {
+		return JSON.parse(raw);
+	} catch (e) {
+		throw new Error(`${label} exists but is not valid JSON: ${e instanceof Error ? e.message : String(e)}\nRefusing to continue — overwriting it would destroy whatever it holds.\nRepair the file, or move it aside and re-run this command.`);
+	}
+}
+/**
+* Write JSON without risking the existing file.
+*
+* Keeps a `.bak-pai` copy of the previous contents, then writes to a temp file
+* and renames. Rename is atomic within a filesystem, so a crash mid-write
+* leaves the original intact rather than truncated — which is how these files
+* become corrupt in the first place.
+*/
+function writeJsonAtomic(path, data, opts = {}) {
+	const { backup = true, label = path } = opts;
+	const serialized = JSON.stringify(data, null, 2) + "\n";
+	const dir = dirname(path);
+	if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+	if (backup && existsSync(path)) try {
+		copyFileSync(path, `${path}.bak-pai`);
+	} catch (e) {
+		throw new Error(`Could not back up ${label}: ${e instanceof Error ? e.message : String(e)}\nRefusing to write without a backup.`);
+	}
+	const tmp = `${path}.tmp-pai-${process.pid}`;
+	try {
+		writeFileSync(tmp, serialized, "utf8");
+		renameSync(tmp, path);
+	} catch (e) {
+		try {
+			if (existsSync(tmp)) unlinkSync(tmp);
+		} catch {}
+		throw new Error(`Failed to write ${label}: ${e instanceof Error ? e.message : String(e)}\nThe original is unchanged.`);
+	}
+}
+
 //#endregion
 //#region src/cli/commands/setup/utils.ts
 /**
@@ -2741,17 +2821,18 @@ async function promptYesNo(rl, question, defaultYes = true) {
 	if (answer === "") return defaultYes;
 	return answer.toLowerCase().startsWith("y");
 }
+/**
+* This file holds the Postgres connection string, the storage backend choice,
+* notification routing and any tracker API token — none of which the user can
+* reconstruct from memory. It previously returned {} on a parse failure and
+* then overwrote the file, so a damaged config was replaced by whatever the
+* current command happened to be setting.
+*/
 function readConfigRaw() {
-	if (!existsSync(CONFIG_FILE$2)) return {};
-	try {
-		return JSON.parse(readFileSync(CONFIG_FILE$2, "utf-8"));
-	} catch {
-		return {};
-	}
+	return readJsonStrict(CONFIG_FILE$2, "~/.config/pai/config.json");
 }
 function writeConfigRaw(data) {
-	if (!existsSync(CONFIG_DIR)) mkdirSync(CONFIG_DIR, { recursive: true });
-	writeFileSync(CONFIG_FILE$2, JSON.stringify(data, null, 2) + "\n", "utf-8");
+	writeJsonAtomic(CONFIG_FILE$2, data, { label: "~/.config/pai/config.json" });
 }
 function mergeConfig(updates) {
 	const current = readConfigRaw();
@@ -3434,27 +3515,18 @@ async function stepTsHooks(rl) {
 
 //#endregion
 //#region src/cli/commands/settings-manager.ts
+const SETTINGS_FILE = join(join(homedir(), ".claude"), "settings.json");
 /**
-* settings-manager — merge-not-overwrite utility for ~/.claude/settings.json
-*
-* Provides safe, idempotent writes to Claude Code's settings.json:
-*   - env vars: added only if the key is absent (never overwrites)
-*   - hooks: appended per hookType, deduplicated by command string
-*   - statusLine: written only if the key is not already present
+* ~/.claude/settings.json is Claude Code's own file, not ours: hooks, env,
+* permissions, statusline, enabled plugins. PAI only ever adds to it. Returning
+* {} for a damaged file and then writing meant a stray parse error could strip
+* every hook registration the user had.
 */
-const CLAUDE_DIR = join(homedir(), ".claude");
-const SETTINGS_FILE = join(CLAUDE_DIR, "settings.json");
 function readSettingsJson() {
-	if (!existsSync(SETTINGS_FILE)) return {};
-	try {
-		return JSON.parse(readFileSync(SETTINGS_FILE, "utf-8"));
-	} catch {
-		return {};
-	}
+	return readJsonStrict(SETTINGS_FILE, "~/.claude/settings.json");
 }
 function writeSettingsJson(data) {
-	if (!existsSync(CLAUDE_DIR)) mkdirSync(CLAUDE_DIR, { recursive: true });
-	writeFileSync(SETTINGS_FILE, JSON.stringify(data, null, 2) + "\n", "utf-8");
+	writeJsonAtomic(SETTINGS_FILE, data, { label: "~/.claude/settings.json" });
 }
 /**
 * Merge env vars — add keys that are absent, never overwrite existing ones.
@@ -4256,6 +4328,33 @@ var TodoistProvider = class {
 			sourceUrl: `https://app.todoist.com/app/task/${created.id}`
 		};
 	}
+	/**
+	* Replace a task's labels.
+	*
+	* Only ever sends `labels`. Never `due_date`: writing that field destroys a
+	* recurrence rule, silently turning a routine into a one-off. Measured — it
+	* cost me an invalid test before it cost anyone a schedule.
+	*/
+	async setLabels(id, labels) {
+		const token = this.token();
+		if (!token) throw new Error("Todoist provider is not configured — run `pai task config`.");
+		await call(token, `/tasks/${id}`, {
+			method: "POST",
+			body: { labels }
+		});
+	}
+	/** Append a comment — used to keep run history on the task itself. */
+	async comment(id, content) {
+		const token = this.token();
+		if (!token) throw new Error("Todoist provider is not configured — run `pai task config`.");
+		await call(token, `/comments`, {
+			method: "POST",
+			body: {
+				task_id: id,
+				content
+			}
+		});
+	}
 	async complete(id) {
 		const token = this.token();
 		if (!token) throw new Error("Todoist provider is not configured — run `pai setup`.");
@@ -6663,6 +6762,77 @@ var AiBrokerTransport = class {
 	}
 };
 /**
+* Liveness prober backed by `aibroker ask`.
+*
+* Separate from Transport on purpose: asking must NEVER spawn. A probe that
+* creates the session it is probing for turns "this session died" into "all is
+* well", which is the failure the probe exists to catch.
+*/
+var AiBrokerProber = class {
+	constructor(bin = "aibroker", timeoutSecs = 60) {
+		this.bin = bin;
+		this.timeoutSecs = timeoutSecs;
+	}
+	async ask(project, question) {
+		let stdout;
+		try {
+			stdout = await run(this.bin, [
+				"ask",
+				project,
+				"--stdin",
+				"--json",
+				"--timeout",
+				String(this.timeoutSecs)
+			], question, this.timeoutSecs * 1e3 + KILL_MARGIN_MS);
+		} catch (e) {
+			return {
+				replied: false,
+				reason: e instanceof Error ? e.message : String(e)
+			};
+		}
+		const start = stdout.lastIndexOf("{");
+		if (start === -1) return {
+			replied: false,
+			reason: "aibroker returned no JSON"
+		};
+		try {
+			const wire = JSON.parse(stdout.slice(start));
+			return wire.replied === true ? {
+				replied: true,
+				reply: wire.reply
+			} : {
+				replied: false,
+				reason: wire.reason ?? "no reply"
+			};
+		} catch {
+			return {
+				replied: false,
+				reason: "aibroker returned malformed JSON"
+			};
+		}
+	}
+};
+/**
+* Return a prober if the installed `aibroker` supports `ask`.
+*
+* Probes for the subcommand rather than the binary: an older AIBroker would
+* otherwise fail once per stuck task instead of the scheduler simply knowing it
+* has no liveness check and saying so.
+*/
+async function detectProber(bin = "aibroker") {
+	try {
+		const help = await new Promise((resolve, reject) => {
+			execFile(bin, ["help"], { timeout: 1e4 }, (error, stdout, stderr) => {
+				if (error && !stdout) reject(error);
+				else resolve(stdout + stderr);
+			});
+		});
+		return /\bask\b/.test(help) ? new AiBrokerProber(bin) : null;
+	} catch {
+		return null;
+	}
+}
+/**
 * Return a transport if the `aibroker` CLI is present and supports dispatch.
 *
 * Probing for the subcommand rather than just the binary matters: AIBroker
@@ -6682,6 +6852,388 @@ async function detectAiBroker(bin = "aibroker", timeoutSecs = DEFAULT_DISPATCH_T
 	}
 }
 
+//#endregion
+//#region src/tasks/scheduler.ts
+/** Set when dispatched, cleared when the due date advances. */
+const RUNNING_LABEL = "pai-running";
+/** `pai-skip-if-late:4h` — past that, the window is gone; wait for the next. */
+const SKIP_IF_LATE_RE = /^pai-skip-if-late:(\d+)([hm])$/i;
+/** Fallback when a task has no learned duration yet. */
+const DEFAULT_EXPECTED_MINUTES = 30;
+/** Probe once the run exceeds expected x this. */
+const PROBE_FACTOR = 1.5;
+/** Consecutive unanswered probes before a run counts as stuck. */
+const STUCK_AFTER_FAILED_PROBES = 3;
+const EMPTY_RUN_STATE = {
+	startedAt: {},
+	failedProbes: {}
+};
+function isRunning(task) {
+	return task.labels.some((l) => l.toLowerCase() === RUNNING_LABEL);
+}
+/** Minutes after which a missed window is abandoned, or null for "always run". */
+function skipIfLateMinutes(task) {
+	for (const label of task.labels) {
+		const m = SKIP_IF_LATE_RE.exec(label.trim());
+		if (m) {
+			const n = Number.parseInt(m[1], 10);
+			return m[2].toLowerCase() === "h" ? n * 60 : n;
+		}
+	}
+	return null;
+}
+/**
+* How overdue a task is, in minutes. Negative means still in the future.
+*
+* A date-only due ("2026-08-01") is treated as due at the start of that day,
+* which is what Todoist shows the user.
+*/
+function overdueMinutes(task, now) {
+	if (!task.due) return Number.NEGATIVE_INFINITY;
+	const due = task.due.length <= 10 ? `${task.due}T00:00:00` : task.due;
+	const dueMs = new Date(due).getTime();
+	if (Number.isNaN(dueMs)) return Number.NEGATIVE_INFINITY;
+	return Math.floor((now - dueMs) / 6e4);
+}
+/**
+* Expected runtime for a task.
+*
+* The mean rather than the max, deliberately: with a liveness probe available,
+* guessing low costs one extra probe, while guessing high leaves a dead session
+* undetected for far longer. The probe is what makes a tight estimate safe.
+*
+* Runs that ended in stuck or re-dispatch must never be fed in here — one hung
+* run would inflate the mean and every later run would inherit a too-generous
+* threshold.
+*/
+function expectedMinutes(observed, fallback = DEFAULT_EXPECTED_MINUTES) {
+	const clean = observed.filter((n) => Number.isFinite(n) && n > 0);
+	if (clean.length === 0) return fallback;
+	const recent = clean.slice(-5);
+	return Math.max(1, Math.round(recent.reduce((a, b) => a + b, 0) / recent.length));
+}
+/**
+* Decide what should happen to one task on this tick.
+*
+* Pure: no I/O, no clock reads. Everything comes in via options so the state
+* machine can be tested against a fixed clock rather than by waiting.
+*/
+function decide(task, opts) {
+	const { now, state } = opts;
+	const running = isRunning(task);
+	const overdue = overdueMinutes(task, now);
+	const startedAt = state.startedAt[task.id];
+	if (running) {
+		if (overdue < 0) return {
+			action: "complete",
+			task,
+			durationMinutes: startedAt ? Math.max(1, Math.round((now - startedAt) / 6e4)) : null
+		};
+		if (startedAt === void 0) return {
+			action: "orphaned",
+			task,
+			reason: "marked running but no start time is known — probe before assuming anything"
+		};
+		const elapsed = Math.max(0, Math.round((now - startedAt) / 6e4));
+		const expected = expectedMinutes(opts.history?.[task.id] ?? []);
+		if (elapsed >= expected * PROBE_FACTOR) return {
+			action: "probe",
+			task,
+			elapsedMinutes: elapsed,
+			expectedMinutes: expected
+		};
+		return {
+			action: "running",
+			task,
+			elapsedMinutes: elapsed
+		};
+	}
+	if (overdue < 0) return {
+		action: "wait",
+		task
+	};
+	const limit = skipIfLateMinutes(task);
+	if (limit !== null && overdue > limit) return {
+		action: "skip",
+		task,
+		reason: `overdue by ${overdue}m, past its ${limit}m window — waiting for the next occurrence`
+	};
+	return {
+		action: "dispatch",
+		task,
+		overdueMinutes: Math.max(0, overdue)
+	};
+}
+/**
+* Order tasks for dispatch.
+*
+* Subtasks of the same parent run in Todoist's own order, so a routine is
+* sequenced by dragging its steps in the UI. Everything else falls back to
+* priority then due time, so the most overdue urgent thing goes first.
+*/
+function dispatchOrder(tasks) {
+	const rank = {
+		p1: 0,
+		p2: 1,
+		p3: 2,
+		p4: 3
+	};
+	return [...tasks].sort((a, b) => {
+		const p = rank[a.priority] - rank[b.priority];
+		if (p !== 0) return p;
+		return (a.due ?? "").localeCompare(b.due ?? "");
+	});
+}
+
+//#endregion
+//#region src/tasks/poller.ts
+/**
+* poller.ts — one scheduler tick
+*
+* Reads Todoist, decides, acts, reports. Run by launchd on an interval; carries
+* no LLM, so a tick that finds nothing to do costs one API call and no tokens.
+*
+* Run state (start times, probe counts) is deliberately local and transient.
+* Losing it costs one extra probe, not a wrong decision — `decide` returns
+* "orphaned" rather than assuming a task is dead. The durable state — schedule,
+* order, running flag, learned durations — all lives in Todoist, so a new
+* machine picks up where this one left off.
+*/
+const STATE_FILE$1 = join(homedir(), ".pai", "scheduler-state.json");
+/** How many past durations to keep per task. */
+const HISTORY_LIMIT = 5;
+const EMPTY = {
+	...EMPTY_RUN_STATE,
+	history: {},
+	lastReported: {}
+};
+/**
+* Run state is a rebuildable cache, so a damaged file must not block the
+* scheduler forever — starting fresh is the correct recovery here, which is
+* exactly the case json-store's guard is NOT for.
+*/
+function loadState$1() {
+	try {
+		const raw = readJsonStrict(STATE_FILE$1, "~/.pai/scheduler-state.json");
+		return {
+			...EMPTY,
+			...raw
+		};
+	} catch {
+		return { ...EMPTY };
+	}
+}
+function saveState$1(state) {
+	writeJsonAtomic(STATE_FILE$1, state, { backup: false });
+}
+async function tick(opts) {
+	const now = opts.now ?? Date.now();
+	const state = loadState$1();
+	const report = {
+		decisions: [],
+		dispatched: 0,
+		completed: 0,
+		stuck: 0,
+		probed: 0
+	};
+	const ordered = dispatchOrder(await opts.provider.listOpen({ includeUnrouted: true }));
+	for (const task of ordered) {
+		const d = decide(task, {
+			now,
+			state,
+			history: state.history
+		});
+		let note = "";
+		switch (d.action) {
+			case "wait": continue;
+			case "skip":
+				note = d.reason;
+				break;
+			case "running":
+				note = `${d.elapsedMinutes}m elapsed`;
+				break;
+			case "dispatch":
+				note = await handleDispatch(task, d.overdueMinutes, opts, state, now);
+				if (!opts.dryRun) report.dispatched++;
+				break;
+			case "complete":
+				note = await handleComplete(task, d.durationMinutes, opts, state);
+				if (!opts.dryRun) report.completed++;
+				break;
+			case "probe":
+			case "orphaned": {
+				const result = await handleProbe(task, d.action === "probe" ? d.elapsedMinutes : null, opts, state);
+				note = result.note;
+				if (!opts.dryRun) {
+					report.probed++;
+					if (result.stuck) report.stuck++;
+				}
+				break;
+			}
+		}
+		report.decisions.push({
+			decision: d,
+			note
+		});
+	}
+	if (!opts.dryRun) saveState$1(state);
+	return report;
+}
+async function handleDispatch(task, overdue, opts, state, now) {
+	const late = overdue > 5 ? ` (${overdue}m late)` : "";
+	if (opts.dryRun) return `would dispatch to ${task.owner.project ?? "nobody"}${late}`;
+	if (!task.owner.project) return "unrouted — cannot dispatch";
+	const result = await dispatchTask(task, {
+		transport: opts.transport,
+		autoDispatch: opts.autoDispatch,
+		spawnIfAbsent: true
+	});
+	if (result.outcome === "delivered" || result.outcome === "spawned") {
+		await opts.provider.setLabels(task.id, [...task.labels, RUNNING_LABEL]);
+		state.startedAt[task.id] = now;
+		delete state.failedProbes[task.id];
+		return `${result.outcome} to ${result.session}${late}`;
+	}
+	return `not dispatched: ${result.outcome}${result.reason ? " — " + result.reason : ""}`;
+}
+async function handleComplete(task, durationMinutes, opts, state) {
+	if (opts.dryRun) return `would clear ${RUNNING_LABEL}, ${durationMinutes ?? "?"}m`;
+	await opts.provider.setLabels(task.id, task.labels.filter((l) => l.toLowerCase() !== RUNNING_LABEL));
+	const wasStuck = (state.failedProbes[task.id] ?? 0) > 0;
+	delete state.startedAt[task.id];
+	delete state.failedProbes[task.id];
+	if (durationMinutes !== null && !wasStuck) {
+		const hist = state.history[task.id] ?? [];
+		hist.push(durationMinutes);
+		state.history[task.id] = hist.slice(-HISTORY_LIMIT);
+	}
+	return durationMinutes === null ? "completed (duration unknown)" : `completed in ${durationMinutes}m${wasStuck ? " — not recorded, run was probed" : ""}`;
+}
+async function handleProbe(task, elapsed, opts, state) {
+	const project = task.owner.project;
+	const el = elapsed === null ? "unknown" : `${elapsed}m`;
+	if (opts.dryRun) return {
+		note: `would probe ${project ?? "?"} (${el} elapsed)`,
+		stuck: false
+	};
+	if (!opts.prober || !project) return {
+		note: `overrun (${el}) — no liveness probe available, leaving alone`,
+		stuck: false
+	};
+	const answer = await opts.prober.ask(project, `Are you still working on the task "${task.title}"? Reply in one short line.`);
+	if (answer.replied) {
+		state.failedProbes[task.id] = 0;
+		return {
+			note: `alive after ${el}: ${answer.reply ?? "(no detail)"}`,
+			stuck: false
+		};
+	}
+	const fails = (state.failedProbes[task.id] ?? 0) + 1;
+	state.failedProbes[task.id] = fails;
+	if (fails >= STUCK_AFTER_FAILED_PROBES) return {
+		note: `STUCK after ${el} and ${fails} unanswered probes (${answer.reason ?? "no reply"}) — needs attention`,
+		stuck: true
+	};
+	return {
+		note: `no reply ${fails}/${STUCK_AFTER_FAILED_PROBES} after ${el}`,
+		stuck: false
+	};
+}
+
+//#endregion
+//#region src/tasks/schedule-install.ts
+/**
+* schedule-install.ts — install the scheduler tick as a launchd agent
+*
+* Two speeds were considered and rejected in favour of one: a fixed interval.
+* A 15-minute tick is 96 runs a day, each one API call and zero tokens, and
+* daily routines do not need better than 15-minute granularity — a 09:00 sweep
+* starting at 09:12 is fine. Adaptive intervals would add a second thing that
+* can silently stop.
+*
+* StartInterval rather than StartCalendarInterval on purpose: the schedule
+* lives in Todoist, not here. This agent only decides how often to *look*.
+* That means one plist total, however many routines exist, and rescheduling a
+* routine never touches the machine.
+*/
+const SCHEDULE_LABEL = "com.pai.task-scheduler";
+const LAUNCH_AGENTS = join(homedir(), "Library", "LaunchAgents");
+const SCHEDULE_PLIST = join(LAUNCH_AGENTS, `${SCHEDULE_LABEL}.plist`);
+const SCHEDULE_LOG = "/tmp/pai-scheduler.log";
+/** Default tick, in seconds. */
+const DEFAULT_INTERVAL_SECS = 900;
+function cliPath() {
+	return fileURLToPath(new URL("index.mjs", import.meta.url));
+}
+function generateSchedulePlist(intervalSecs, cli) {
+	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>${SCHEDULE_LABEL}</string>
+
+    <key>ProgramArguments</key>
+    <array>
+        <string>/usr/local/bin/node</string>
+        <string>${cli}</string>
+        <string>task</string>
+        <string>poll</string>
+    </array>
+
+    <key>StartInterval</key>
+    <integer>${intervalSecs}</integer>
+
+    <key>RunAtLoad</key>
+    <true/>
+
+    <key>StandardOutPath</key>
+    <string>${SCHEDULE_LOG}</string>
+
+    <key>StandardErrorPath</key>
+    <string>${SCHEDULE_LOG}</string>
+
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>PATH</key>
+        <string>/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin</string>
+    </dict>
+</dict>
+</plist>
+`;
+}
+function installSchedule(intervalSecs = DEFAULT_INTERVAL_SECS) {
+	if (!existsSync(LAUNCH_AGENTS)) mkdirSync(LAUNCH_AGENTS, { recursive: true });
+	writeFileSync(SCHEDULE_PLIST, generateSchedulePlist(intervalSecs, cliPath()), "utf8");
+	spawnSync("launchctl", ["unload", SCHEDULE_PLIST], { encoding: "utf8" });
+	const load = spawnSync("launchctl", ["load", SCHEDULE_PLIST], { encoding: "utf8" });
+	return {
+		plistPath: SCHEDULE_PLIST,
+		intervalSecs,
+		loaded: load.status === 0,
+		message: load.status === 0 ? `Scheduler installed — ticking every ${Math.round(intervalSecs / 60)} min.` : `Plist written but launchctl load failed: ${(load.stderr || "").trim()}`
+	};
+}
+function uninstallSchedule() {
+	if (!existsSync(SCHEDULE_PLIST)) return "Scheduler is not installed.";
+	spawnSync("launchctl", ["unload", SCHEDULE_PLIST], { encoding: "utf8" });
+	unlinkSync(SCHEDULE_PLIST);
+	return "Scheduler uninstalled.";
+}
+function scheduleStatus() {
+	if (!existsSync(SCHEDULE_PLIST)) return {
+		installed: false,
+		running: false,
+		detail: "Not installed."
+	};
+	const running = spawnSync("launchctl", ["list", SCHEDULE_LABEL], { encoding: "utf8" }).status === 0;
+	return {
+		installed: true,
+		running,
+		detail: running ? `Loaded. Log: ${SCHEDULE_LOG}` : "Plist present but not loaded — run `pai task schedule install` again."
+	};
+}
+
 //#endregion
 //#region src/cli/commands/task.ts
 const dim = chalk.dim;
@@ -6828,6 +7380,54 @@ function registerTaskCommands(taskCmd) {
 			spawnIfAbsent: opts.spawn !== false
 		}));
 	});
+	taskCmd.command("poll").description("One scheduler tick: dispatch what is due, check what is running, report").option("--dry-run", "Show what would happen without touching anything").action(async (opts) => {
+		const provider = buildProvider();
+		if (!provider) return reportUnconfigured();
+		const config = loadConfig();
+		const report = await tick({
+			provider,
+			transport: opts.dryRun ? null : await detectAiBroker(void 0, config.tasks?.dispatchTimeoutSecs),
+			prober: opts.dryRun ? null : await detectProber(),
+			autoDispatch: config.tasks?.autoDispatch ?? false,
+			dryRun: Boolean(opts.dryRun)
+		});
+		if (report.decisions.length === 0) {
+			console.log(dim("  Nothing due, nothing running."));
+			return;
+		}
+		const mark = {
+			dispatch: chalk.green("→"),
+			complete: chalk.green("✓"),
+			running: dim("·"),
+			probe: chalk.yellow("?"),
+			orphaned: chalk.yellow("!"),
+			skip: dim("–"),
+			wait: dim(" ")
+		};
+		console.log();
+		for (const { decision, note } of report.decisions) {
+			console.log(`  ${mark[decision.action] ?? " "} ${decision.task.title}`);
+			if (note) console.log(`      ${dim(note)}`);
+		}
+		console.log();
+		console.log(dim(`  ${report.dispatched} dispatched, ${report.completed} completed, ${report.probed} probed, ${report.stuck} stuck`));
+		console.log();
+	});
+	const scheduleCmd = taskCmd.command("schedule").description("Install, remove or inspect the launchd agent that ticks the scheduler");
+	scheduleCmd.command("install").description("Install the scheduler tick (default: every 15 minutes)").option("--interval <secs>", "Seconds between ticks", (v) => Number.parseInt(v, 10)).action((opts) => {
+		const r = installSchedule(opts.interval || DEFAULT_INTERVAL_SECS);
+		console.log(r.loaded ? chalk.green(`  ${r.message}`) : chalk.yellow(`  ${r.message}`));
+		console.log(dim(`  ${r.plistPath}`));
+		console.log(dim(`  The schedule itself lives in Todoist — this only sets how often PAI looks.`));
+	});
+	scheduleCmd.command("uninstall").description("Remove the scheduler agent").action(() => console.log(chalk.green(`  ${uninstallSchedule()}`)));
+	scheduleCmd.command("status").description("Show whether the scheduler agent is installed and loaded").action(() => {
+		const s = scheduleStatus();
+		console.log();
+		console.log(`  ${s.installed ? chalk.green("installed") : dim("not installed")}  ${s.installed ? s.running ? chalk.green("· loaded") : chalk.yellow("· not loaded") : ""}`);
+		console.log(dim(`  ${s.detail}`));
+		console.log();
+	});
 	taskCmd.command("config").description("View or change task bus settings without running the full setup wizard").option("--token", "Prompt for the Todoist API token (input is hidden)").option("--from-env", "Adopt the token from TODOIST_API_KEY in the environment").option("--project <id>", "Tracker project ID that roots the bus (an ID, never a name)").option("--findings <id>", "Section ID for the findings inbox").option("--timeout <secs>", "Seconds a single dispatch may take", (v) => Number.parseInt(v, 10)).option("--auto-dispatch <bool>", "Hand tasks to owning sessions automatically (true/false)").option("--disable", "Turn the task bus off without discarding its settings").action(async (opts) => {
 		const raw = readConfigRaw();
 		const tasks = raw.tasks ?? {};
@@ -9061,4 +9661,4 @@ async function cmdPick(db, opts = {}) {
 
 //#endregion
 export { registerDaemonCommands as C, registerProjectsCommands as D, registerRegistryCommands as E, findMovedPath as O, registerBackupCommands as S, registerMemoryCommands as T, registerObservationCommands as _, cmdPauseAll as a, registerSetupCommand as b, cmdPause as c, registerKgCommands as d, registerTopicCommands as f, registerSkillCommands as g, registerUpdateCommand as h, cmdClearNames as i, resolveIdentifier as k, registerHelpCommand as l, registerNotifyCommands as m, cmdFind as n, cmdGoto as o, registerTaskCommands as p, cmdList as r, cmdEnd as s, cmdPick as t, registerDbCommands as u, registerZettelCommands as v, registerMcpCommands as w, registerRestoreCommands as x, registerObsidianCommands as y };
-//# sourceMappingURL=pick-CmG7SCtp.mjs.map
+//# sourceMappingURL=pick-DxS6p2vI.mjs.map