@tekmidian/pai 0.13.5 → 0.14.1

package/dist/cli/index.mjs

@@ -6,7 +6,7 @@ import "../db-CmYbAVCD.mjs";
 import "../helpers-IjZkXBhj.mjs";
 import "../embeddings-BJPOcbik.mjs";
 import "../search-HcdKtMla.mjs";
-import "../pick-CsHZ8Abv.mjs";
+import "../pick-BPlB38eB.mjs";
 import "../kg-extraction-C8DEUHTS.mjs";
 import "../factory-Q88X1bAN.mjs";
 import "../config-C8m-tPhP.mjs";

package/dist/cli/program.mjs

@@ -5,7 +5,7 @@ import "../db-CmYbAVCD.mjs";
 import "../helpers-IjZkXBhj.mjs";
 import "../embeddings-BJPOcbik.mjs";
 import "../search-HcdKtMla.mjs";
-import { C as registerDaemonCommands, D as registerProjectsCommands, E as registerRegistryCommands, O as findMovedPath, S as registerBackupCommands, T as registerMemoryCommands, _ as registerObservationCommands, a as cmdPauseAll, b as registerSetupCommand, c as cmdPause, d as registerKgCommands, f as registerTopicCommands, g as registerSkillCommands, h as registerUpdateCommand, i as cmdClearNames, k as resolveIdentifier, l as registerHelpCommand, m as registerNotifyCommands, n as cmdFind, o as cmdGoto, p as registerTaskCommands, r as cmdList, s as cmdEnd, t as cmdPick, u as registerDbCommands, v as registerZettelCommands, w as registerMcpCommands, x as registerRestoreCommands, y as registerObsidianCommands } from "../pick-CsHZ8Abv.mjs";
+import { C as registerDaemonCommands, D as registerProjectsCommands, E as registerRegistryCommands, O as findMovedPath, S as registerBackupCommands, T as registerMemoryCommands, _ as registerObservationCommands, a as cmdPauseAll, b as registerSetupCommand, c as cmdPause, d as registerKgCommands, f as registerTopicCommands, g as registerSkillCommands, h as registerUpdateCommand, i as cmdClearNames, k as resolveIdentifier, l as registerHelpCommand, m as registerNotifyCommands, n as cmdFind, o as cmdGoto, p as registerTaskCommands, r as cmdList, s as cmdEnd, t as cmdPick, u as registerDbCommands, v as registerZettelCommands, w as registerMcpCommands, x as registerRestoreCommands, y as registerObsidianCommands } from "../pick-BPlB38eB.mjs";
 import "../kg-extraction-C8DEUHTS.mjs";
 import "../factory-Q88X1bAN.mjs";
 import "../config-C8m-tPhP.mjs";

package/dist/{pick-CsHZ8Abv.mjs → pick-BPlB38eB.mjs}

@@ -4328,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`.");
@@ -6735,6 +6762,80 @@ 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 {
+				state: "silent",
+				reason: e instanceof Error ? e.message : String(e)
+			};
+		}
+		const start = stdout.lastIndexOf("{");
+		if (start === -1) return {
+			state: "silent",
+			reason: "aibroker returned no JSON"
+		};
+		try {
+			const wire = JSON.parse(stdout.slice(start));
+			const state = wire.state ?? (wire.replied === true ? "replied" : "silent");
+			if (state === "replied" || state === "busy" || state === "silent" || state === "absent") return {
+				state,
+				reply: wire.reply,
+				reason: wire.reason
+			};
+			return {
+				state: "silent",
+				reason: `unexpected state from aibroker: ${String(wire.state)}`
+			};
+		} catch {
+			return {
+				state: "silent",
+				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
@@ -6754,6 +6855,403 @@ 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 });
+}
+/**
+* Multiple of the expected duration past which a task is flagged even though it
+* keeps reporting `busy`. A session can be alive and still wrong — stuck in a
+* loop, waiting on a prompt that will never come. Liveness is not progress.
+*/
+const GROSS_OVERRUN_FACTOR = 5;
+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.state === "replied" || answer.state === "busy") {
+		state.failedProbes[task.id] = 0;
+		const expected = expectedMinutes(state.history[task.id] ?? []);
+		if (elapsed !== null && elapsed > expected * GROSS_OVERRUN_FACTOR) return {
+			note: `alive but ${el} against an expected ${expected}m — ${GROSS_OVERRUN_FACTOR}x over, worth a look`,
+			stuck: true
+		};
+		return answer.state === "busy" ? {
+			note: `busy after ${el} (mid-turn, nothing sent)`,
+			stuck: false
+		} : {
+			note: `alive after ${el}: ${answer.reply ?? "(no detail)"}`,
+			stuck: false
+		};
+	}
+	const fails = (state.failedProbes[task.id] ?? 0) + 1;
+	state.failedProbes[task.id] = fails;
+	const what = answer.state === "absent" ? "session gone" : "no reply";
+	if (fails >= STUCK_AFTER_FAILED_PROBES) return {
+		note: `STUCK after ${el} — ${what} x${fails} (${answer.reason ?? "no detail"})`,
+		stuck: true
+	};
+	return {
+		note: `${what} ${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;
@@ -6900,6 +7398,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 ?? {};
@@ -9133,4 +9679,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-CsHZ8Abv.mjs.map
+//# sourceMappingURL=pick-BPlB38eB.mjs.map