granola-toolkit 0.21.1 → 0.22.0

package/README.md

@@ -33,6 +33,7 @@ Installed command:
 ```bash
 granola --help
 granola auth login
+granola exports --help
 granola meeting --help
 granola notes --help
 granola serve --help
@@ -47,6 +48,7 @@ Local build:
 ```bash
 vp pack
 node dist/cli.js --help
+node dist/cli.js exports --help
 node dist/cli.js meeting --help
 node dist/cli.js notes --help
 node dist/cli.js serve --help
@@ -73,6 +75,8 @@ granola notes
 
 node dist/cli.js notes --supabase "$HOME/Library/Application Support/Granola/supabase.json"
 node dist/cli.js notes --format json --output ./notes-json
+granola exports list
+granola exports rerun notes-1234abcd
 ```
 
 Export transcripts:
@@ -194,7 +198,9 @@ The initial server API includes:
 - `GET /meetings`
 - `GET /meetings/resolve?q=<query>`
 - `GET /meetings/:id`
+- `GET /exports/jobs`
 - `POST /exports/notes`
+- `POST /exports/jobs/:id/rerun`
 - `POST /exports/transcripts`
 
 This is the foundation for the future `granola web` client and any attachable TUI flows.
@@ -212,8 +218,20 @@ The initial browser client includes:
 - keyboard-first workspace switching with `1`-`4`, `[` and `]`
 - app-state status from the shared core
 - note and transcript export actions backed by the same local API
+- a recent export-jobs panel with rerun actions
 - stronger empty and error states for list/detail failures
 
+### Export Jobs
+
+Exports are now tracked as jobs with:
+
+- persistent local history across CLI and web runs
+- running, completed, and failed status
+- per-export progress counters
+- rerun support from `granola exports rerun <job-id>` or the web client
+
+Use `granola exports list` to inspect recent jobs from the CLI.
+
 ## Auth
 
 If you do not want to keep passing `--supabase`, import the desktop app session once:

package/dist/cli.js

@@ -6,7 +6,7 @@ import { homedir, platform } from "node:os";
 import { dirname, join } from "node:path";
 import { promisify } from "node:util";
 import { NodeHtmlMarkdown } from "node-html-markdown";
-import { createHash } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { createServer } from "node:http";
 //#region src/utils.ts
 const INVALID_FILENAME_CHARS = /[<>:"/\\|?*]/g;
@@ -718,6 +718,81 @@ async function loadOptionalGranolaCache(cacheFile) {
 	return parseCacheContents(await readFile(cacheFile, "utf8"));
 }
 //#endregion
+//#region src/export-jobs.ts
+const EXPORT_JOBS_VERSION = 1;
+const MAX_EXPORT_JOBS = 100;
+function normaliseJob(value) {
+	const record = asRecord(value);
+	if (!record) return;
+	const id = stringValue(record.id);
+	const kind = stringValue(record.kind);
+	const status = stringValue(record.status);
+	const format = stringValue(record.format);
+	const outputDir = stringValue(record.outputDir);
+	const startedAt = stringValue(record.startedAt);
+	const itemCount = typeof record.itemCount === "number" && Number.isFinite(record.itemCount) ? record.itemCount : 0;
+	const written = typeof record.written === "number" && Number.isFinite(record.written) ? record.written : 0;
+	const completedCount = typeof record.completedCount === "number" && Number.isFinite(record.completedCount) ? record.completedCount : written;
+	if (!id || !format || !outputDir || !startedAt || kind !== "notes" && kind !== "transcripts" || status !== "running" && status !== "completed" && status !== "failed") return;
+	return {
+		completedCount,
+		error: stringValue(record.error) || void 0,
+		finishedAt: stringValue(record.finishedAt) || void 0,
+		format,
+		id,
+		itemCount,
+		kind,
+		outputDir,
+		startedAt,
+		status,
+		written
+	};
+}
+function normaliseJobsFile(parsed) {
+	const record = asRecord(parsed);
+	if (!record || record.version !== EXPORT_JOBS_VERSION || !Array.isArray(record.jobs)) return {
+		jobs: [],
+		version: EXPORT_JOBS_VERSION
+	};
+	return {
+		jobs: record.jobs.map((job) => normaliseJob(job)).filter((job) => Boolean(job)).slice(0, MAX_EXPORT_JOBS),
+		version: EXPORT_JOBS_VERSION
+	};
+}
+function createExportJobId(kind) {
+	return `${kind}-${randomUUID()}`;
+}
+function defaultExportJobsFilePath() {
+	const home = homedir();
+	return platform() === "darwin" ? join(home, "Library", "Application Support", "granola-toolkit", "export-jobs.json") : join(home, ".config", "granola-toolkit", "export-jobs.json");
+}
+var FileExportJobStore = class {
+	constructor(filePath = defaultExportJobsFilePath()) {
+		this.filePath = filePath;
+	}
+	async readJobs() {
+		try {
+			return normaliseJobsFile(parseJsonString(await readFile(this.filePath, "utf8"))).jobs;
+		} catch {
+			return [];
+		}
+	}
+	async writeJobs(jobs) {
+		const payload = {
+			jobs: jobs.slice(0, MAX_EXPORT_JOBS),
+			version: EXPORT_JOBS_VERSION
+		};
+		await mkdir(dirname(this.filePath), { recursive: true });
+		await writeFile(this.filePath, `${JSON.stringify(payload, null, 2)}\n`, {
+			encoding: "utf8",
+			mode: 384
+		});
+	}
+};
+function createDefaultExportJobStore() {
+	return new FileExportJobStore();
+}
+//#endregion
 //#region src/export-state.ts
 const EXPORT_STATE_VERSION = 1;
 function exportStatePath(outputDir, kind) {
@@ -783,7 +858,7 @@ function entryChanged(left, right) {
 	if (!left) return true;
 	return left.contentHash !== right.contentHash || left.exportedAt !== right.exportedAt || left.fileName !== right.fileName || left.fileStem !== right.fileStem || left.sourceUpdatedAt !== right.sourceUpdatedAt;
 }
-async function syncManagedExports({ items, kind, outputDir }) {
+async function syncManagedExports({ items, kind, onProgress, outputDir }) {
 	await ensureDirectory(outputDir);
 	const previousEntries = (await loadExportState(outputDir, kind)).entries;
 	const used = /* @__PURE__ */ new Map();
@@ -804,6 +879,7 @@ async function syncManagedExports({ items, kind, outputDir }) {
 	const activeFileNames = new Set(plans.map((plan) => plan.fileName));
 	const exportedAt = (/* @__PURE__ */ new Date()).toISOString();
 	const nextEntries = {};
+	let completed = 0;
 	let written = 0;
 	let stateChanged = false;
 	for (const plan of plans) {
@@ -822,6 +898,12 @@ async function syncManagedExports({ items, kind, outputDir }) {
 		};
 		nextEntries[plan.id] = nextEntry;
 		stateChanged = stateChanged || entryChanged(plan.existing, nextEntry);
+		completed += 1;
+		if (onProgress) await onProgress({
+			completed,
+			total: plans.length,
+			written
+		});
 	}
 	for (const plan of plans) {
 		const previousFileName = plan.existing?.fileName;
@@ -1106,7 +1188,7 @@ function noteFileExtension(format) {
 		case "markdown": return ".md";
 	}
 }
-async function writeNotes(documents, outputDir, format = "markdown") {
+async function writeNotes(documents, outputDir, format = "markdown", options = {}) {
 	return await syncManagedExports({
 		items: [...documents].sort((left, right) => compareStrings(left.title || left.id, right.title || right.id) || compareStrings(left.id, right.id)).map((document) => {
 			const note = buildNoteExport(document);
@@ -1119,6 +1201,7 @@ async function writeNotes(documents, outputDir, format = "markdown") {
 			};
 		}),
 		kind: "notes",
+		onProgress: options.onProgress,
 		outputDir
 	});
 }
@@ -1230,7 +1313,7 @@ function transcriptFileExtension(format) {
 		case "yaml": return ".yaml";
 	}
 }
-async function writeTranscripts(cacheData, outputDir, format = "text") {
+async function writeTranscripts(cacheData, outputDir, format = "text", options = {}) {
 	return await syncManagedExports({
 		items: Object.entries(cacheData.transcripts).filter(([, segments]) => segments.length > 0).sort(([leftId], [rightId]) => {
 			const leftDocument = cacheData.documents[leftId];
@@ -1254,6 +1337,7 @@ async function writeTranscripts(cacheData, outputDir, format = "text") {
 			}];
 		}),
 		kind: "transcripts",
+		onProgress: options.onProgress,
 		outputDir
 	});
 }
@@ -1514,6 +1598,9 @@ function transcriptCount(cacheData) {
 function cloneExportState(state) {
 	return state ? { ...state } : void 0;
 }
+function cloneExportJob(job) {
+	return { ...job };
+}
 function cloneState(state) {
 	return {
 		auth: { ...state.auth },
@@ -1525,6 +1612,7 @@ function cloneState(state) {
 		},
 		documents: { ...state.documents },
 		exports: {
+			jobs: state.exports.jobs.map((job) => cloneExportJob(job)),
 			notes: cloneExportState(state.exports.notes),
 			transcripts: cloneExportState(state.exports.transcripts)
 		},
@@ -1550,7 +1638,7 @@ function defaultState(config, auth, surface) {
 			count: 0,
 			loaded: false
 		},
-		exports: {},
+		exports: { jobs: [] },
 		ui: {
 			surface,
 			view: "idle"
@@ -1568,6 +1656,7 @@ var GranolaApp = class {
 		this.config = config;
 		this.deps = deps;
 		this.#state = defaultState(config, deps.auth, options.surface ?? "cli");
+		this.#state.exports.jobs = (deps.exportJobs ?? []).map((job) => cloneExportJob(job));
 	}
 	getState() {
 		return cloneState(this.#state);
@@ -1613,6 +1702,55 @@ var GranolaApp = class {
 	missingCacheError() {
 		return /* @__PURE__ */ new Error(`Granola cache file not found. Pass --cache or create .granola.toml. Expected locations include: ${granolaCacheCandidates().join(", ")}`);
 	}
+	async persistExportJobs() {
+		if (!this.deps.exportJobStore) return;
+		await this.deps.exportJobStore.writeJobs(this.#state.exports.jobs);
+	}
+	async updateExportJob(job) {
+		const nextJobs = [cloneExportJob(job), ...this.#state.exports.jobs.filter((candidate) => candidate.id !== job.id).map(cloneExportJob)].slice(0, 100);
+		this.#state.exports.jobs = nextJobs;
+		await this.persistExportJobs();
+		this.emitStateUpdate();
+		return cloneExportJob(job);
+	}
+	async startExportJob(kind, format, itemCount, outputDir) {
+		return await this.updateExportJob({
+			completedCount: 0,
+			format,
+			id: createExportJobId(kind),
+			itemCount,
+			kind,
+			outputDir,
+			startedAt: this.nowIso(),
+			status: "running",
+			written: 0
+		});
+	}
+	async completeExportJob(job, patch) {
+		return await this.updateExportJob({
+			...job,
+			completedCount: patch.completedCount,
+			finishedAt: this.nowIso(),
+			status: "completed",
+			written: patch.written
+		});
+	}
+	async failExportJob(job, error) {
+		const message = error instanceof Error ? error.message : String(error);
+		return await this.updateExportJob({
+			...job,
+			error: message,
+			finishedAt: this.nowIso(),
+			status: "failed"
+		});
+	}
+	async setExportJobProgress(job, patch) {
+		return await this.updateExportJob({
+			...job,
+			completedCount: patch.completedCount,
+			written: patch.written
+		});
+	}
 	async listDocuments() {
 		if (this.#documents) return this.#documents;
 		const documents = await (await this.getGranolaClient()).listDocuments({ timeoutMs: this.config.notes.timeoutMs });
@@ -1701,13 +1839,42 @@ var GranolaApp = class {
 			meeting
 		};
 	}
+	async listExportJobs(options = {}) {
+		const limit = options.limit ?? 20;
+		const jobs = this.#state.exports.jobs.slice(0, limit).map((job) => cloneExportJob(job));
+		this.setUiState({ view: "exports-history" });
+		return { jobs };
+	}
 	async exportNotes(format = "markdown") {
+		return await this.runNotesExport({
+			format,
+			outputDir: this.config.notes.output
+		});
+	}
+	async runNotesExport(options) {
 		const documents = await this.listDocuments();
-		const written = await writeNotes(documents, this.config.notes.output, format);
+		let job = await this.startExportJob("notes", options.format, documents.length, options.outputDir);
+		let written = 0;
+		try {
+			written = await writeNotes(documents, options.outputDir, options.format, { onProgress: async (progress) => {
+				job = await this.setExportJobProgress(job, {
+					completedCount: progress.completed,
+					written: progress.written
+				});
+			} });
+			job = await this.completeExportJob(job, {
+				completedCount: documents.length,
+				written
+			});
+		} catch (error) {
+			await this.failExportJob(job, error);
+			throw error;
+		}
 		this.#state.exports.notes = {
-			format,
+			format: options.format,
 			itemCount: documents.length,
-			outputDir: this.config.notes.output,
+			jobId: job.id,
+			outputDir: options.outputDir,
 			ranAt: this.nowIso(),
 			written
 		};
@@ -1716,20 +1883,44 @@ var GranolaApp = class {
 		return {
 			documentCount: documents.length,
 			documents,
-			format,
-			outputDir: this.config.notes.output,
+			format: options.format,
+			job,
+			outputDir: options.outputDir,
 			written
 		};
 	}
 	async exportTranscripts(format = "text") {
+		return await this.runTranscriptsExport({
+			format,
+			outputDir: this.config.transcripts.output
+		});
+	}
+	async runTranscriptsExport(options) {
 		const cacheData = await this.loadCache({ required: true });
 		if (!cacheData) throw this.missingCacheError();
-		const written = await writeTranscripts(cacheData, this.config.transcripts.output, format);
 		const count = transcriptCount(cacheData);
+		let job = await this.startExportJob("transcripts", options.format, count, options.outputDir);
+		let written = 0;
+		try {
+			written = await writeTranscripts(cacheData, options.outputDir, options.format, { onProgress: async (progress) => {
+				job = await this.setExportJobProgress(job, {
+					completedCount: progress.completed,
+					written: progress.written
+				});
+			} });
+			job = await this.completeExportJob(job, {
+				completedCount: count,
+				written
+			});
+		} catch (error) {
+			await this.failExportJob(job, error);
+			throw error;
+		}
 		this.#state.exports.transcripts = {
-			format,
+			format: options.format,
 			itemCount: count,
-			outputDir: this.config.transcripts.output,
+			jobId: job.id,
+			outputDir: options.outputDir,
 			ranAt: this.nowIso(),
 			written
 		};
@@ -1737,18 +1928,35 @@ var GranolaApp = class {
 		this.setUiState({ view: "transcripts-export" });
 		return {
 			cacheData,
-			format,
-			outputDir: this.config.transcripts.output,
+			format: options.format,
+			job,
+			outputDir: options.outputDir,
 			transcriptCount: count,
 			written
 		};
 	}
+	async rerunExportJob(id) {
+		const job = this.#state.exports.jobs.find((candidate) => candidate.id === id);
+		if (!job) throw new Error(`export job not found: ${id}`);
+		if (job.kind === "notes") return await this.runNotesExport({
+			format: job.format,
+			outputDir: job.outputDir
+		});
+		return await this.runTranscriptsExport({
+			format: job.format,
+			outputDir: job.outputDir
+		});
+	}
 };
 async function createGranolaApp(config, options = {}) {
+	const auth = await inspectDefaultGranolaAuth(config);
+	const exportJobStore = createDefaultExportJobStore();
 	return new GranolaApp(config, {
-		auth: await inspectDefaultGranolaAuth(config),
+		auth,
 		cacheLoader: loadOptionalGranolaCache,
 		createGranolaClient: async () => await createDefaultGranolaRuntime(config, options.logger),
+		exportJobs: await exportJobStore.readJobs(),
+		exportJobStore,
 		now: options.now
 	}, { surface: options.surface });
 }
@@ -1868,6 +2076,106 @@ async function waitForShutdown(close) {
 	});
 }
 //#endregion
+//#region src/commands/exports.ts
+function exportsHelp() {
+	return `Granola exports
+
+Usage:
+  granola exports <list|rerun> [options]
+
+Subcommands:
+  list                Show recent export jobs
+  rerun <job-id>      Rerun a previous notes or transcripts export job
+
+Options:
+  --cache <path>      Path to Granola cache JSON
+  --format <value>    list output format: text, json, yaml (default: text)
+  --limit <n>         Number of jobs to show for list (default: 20)
+  --timeout <value>   Request timeout, e.g. 2m, 30s, 120000 (default: 2m)
+  --supabase <path>   Path to supabase.json
+  --debug             Enable debug logging
+  --config <path>     Path to .granola.toml
+  -h, --help          Show help
+`;
+}
+function resolveListFormat$1(value) {
+	switch (value) {
+		case void 0: return "text";
+		case "json":
+		case "text":
+		case "yaml": return value;
+		default: throw new Error("invalid exports format: expected text, json, or yaml");
+	}
+}
+function parseLimit$1(value) {
+	if (value === void 0) return 20;
+	if (typeof value !== "string" || !/^\d+$/.test(value)) throw new Error("invalid exports limit: expected a positive integer");
+	const limit = Number(value);
+	if (!Number.isInteger(limit) || limit < 1) throw new Error("invalid exports limit: expected a positive integer");
+	return limit;
+}
+function renderExportJobs(jobs, format) {
+	if (format === "json") return toJson({ jobs });
+	if (format === "yaml") return toYaml({ jobs });
+	if (jobs.length === 0) return "No export jobs\n";
+	return `${["ID                           KIND         STATUS      FORMAT      ITEMS   WRITTEN  STARTED", ...jobs.map((job) => {
+		return `${job.id.padEnd(28).slice(0, 28)} ${job.kind.padEnd(12)} ${job.status.padEnd(11)} ${job.format.padEnd(11)} ${String(job.itemCount).padEnd(7)} ${String(job.written).padEnd(8)} ${job.startedAt.slice(0, 19)}`;
+	})].join("\n")}\n`;
+}
+const exportsCommand = {
+	description: "List and rerun tracked export jobs",
+	flags: {
+		cache: { type: "string" },
+		format: { type: "string" },
+		help: { type: "boolean" },
+		limit: { type: "string" },
+		timeout: { type: "string" }
+	},
+	help: exportsHelp,
+	name: "exports",
+	async run({ commandArgs, commandFlags, globalFlags }) {
+		const [action, id] = commandArgs;
+		switch (action) {
+			case "list": return await list$1(commandFlags, globalFlags);
+			case "rerun":
+				if (!id) throw new Error("exports rerun requires a job id");
+				return await rerun(id, commandFlags, globalFlags);
+			case void 0:
+				console.log(exportsHelp());
+				return 1;
+			default: throw new Error("invalid exports command: expected list or rerun");
+		}
+	}
+};
+async function list$1(commandFlags, globalFlags) {
+	const format = resolveListFormat$1(commandFlags.format);
+	const limit = parseLimit$1(commandFlags.limit);
+	const config = await loadConfig({
+		globalFlags,
+		subcommandFlags: commandFlags
+	});
+	debug(config.debug, "using config", config.configFileUsed ?? "(none)");
+	const result = await (await createGranolaApp(config)).listExportJobs({ limit });
+	console.log(renderExportJobs(result.jobs, format).trimEnd());
+	return 0;
+}
+async function rerun(id, commandFlags, globalFlags) {
+	const config = await loadConfig({
+		globalFlags,
+		subcommandFlags: commandFlags
+	});
+	debug(config.debug, "using config", config.configFileUsed ?? "(none)");
+	debug(config.debug, "supabase", config.supabase);
+	debug(config.debug, "cacheFile", config.transcripts.cacheFile || "(none)");
+	const result = await (await createGranolaApp(config)).rerunExportJob(id);
+	if ("documentCount" in result) {
+		console.log(`✓ Reran notes export job ${result.job.id} to ${result.outputDir} (${result.written}/${result.documentCount} written)`);
+		return 0;
+	}
+	console.log(`✓ Reran transcripts export job ${result.job.id} to ${result.outputDir} (${result.written}/${result.transcriptCount} written)`);
+	return 0;
+}
+//#endregion
 //#region src/commands/meeting.ts
 function meetingHelp() {
 	return `Granola meeting
@@ -2116,7 +2424,7 @@ const notesCommand = {
 		const app = await createGranolaApp(config);
 		debug(config.debug, "authMode", app.getState().auth.mode);
 		const result = await app.exportNotes(format);
-		console.log(`✓ Exported ${result.documentCount} notes to ${result.outputDir}`);
+		console.log(`✓ Exported ${result.documentCount} notes to ${result.outputDir} (job ${result.job.id})`);
 		debug(config.debug, "notes written", result.written);
 		return 0;
 	}
@@ -2155,6 +2463,7 @@ const els = {
   detailBody: document.querySelector("[data-detail-body]"),
   detailMeta: document.querySelector("[data-detail-meta]"),
   empty: document.querySelector("[data-empty]"),
+  jobsList: document.querySelector("[data-jobs-list]"),
   list: document.querySelector("[data-meeting-list]"),
   noteButton: document.querySelector("[data-export-notes]"),
   quickOpen: document.querySelector("[data-quick-open]"),
@@ -2238,6 +2547,8 @@ function renderAppState() {
     '<div><span class="status-label">Cache</span><strong>' + escapeHtml(cache) + "</strong></div>",
     "</div>",
   ].join("");
+
+  renderExportJobs();
 }
 
 function renderMeetingList() {
@@ -2350,6 +2661,44 @@ function renderMeetingDetail() {
   ].join("");
 }
 
+function renderExportJobs() {
+  const jobs = state.appState?.exports?.jobs || [];
+  if (jobs.length === 0) {
+    els.jobsList.innerHTML = '<div class="job-empty">No export jobs yet.</div>';
+    return;
+  }
+
+  els.jobsList.innerHTML = jobs
+    .slice(0, 6)
+    .map((job) => {
+      const progress = job.itemCount > 0
+        ? job.completedCount + "/" + job.itemCount + " items"
+        : "0 items";
+      const error = job.error ? '<div class="job-card__meta">' + escapeHtml(job.error) + "</div>" : "";
+      const rerunButton =
+        job.status === "running"
+          ? ""
+          : '<button class="button button--secondary" data-rerun-job-id="' + escapeHtml(job.id) + '">Rerun</button>';
+
+      return [
+        '<article class="job-card">',
+        '<div class="job-card__head">',
+        '<div>',
+        '<div class="job-card__title">' + escapeHtml(job.kind) + " export</div>",
+        '<div class="job-card__meta">' + escapeHtml(job.id) + "</div>",
+        "</div>",
+        '<div class="job-card__status" data-status="' + escapeHtml(job.status) + '">' + escapeHtml(job.status) + "</div>",
+        "</div>",
+        '<div class="job-card__meta">Format: ' + escapeHtml(job.format) + " • " + escapeHtml(progress) + " • Written: " + escapeHtml(String(job.written)) + "</div>",
+        '<div class="job-card__meta">Started: ' + escapeHtml(job.startedAt.slice(0, 19)) + "</div>",
+        error,
+        '<div class="job-card__actions">' + rerunButton + "</div>",
+        "</article>",
+      ].join("");
+    })
+    .join("");
+}
+
 async function fetchJson(path, init) {
   const response = await fetch(path, init);
   const payload = await response.json().catch(() => ({}));
@@ -2482,6 +2831,20 @@ async function exportTranscripts() {
   await refreshAll();
 }
 
+async function rerunJob(id) {
+  setStatus("Rerunning export…", "busy");
+  try {
+    await fetchJson("/exports/jobs/" + encodeURIComponent(id) + "/rerun", {
+      method: "POST",
+    });
+    await refreshAll();
+  } catch (error) {
+    setStatus("Rerun failed", "error");
+    state.detailError = error instanceof Error ? error.message : String(error);
+    renderMeetingDetail();
+  }
+}
+
 els.list.addEventListener("click", (event) => {
   if (!(event.target instanceof Element)) {
     return;
@@ -2492,6 +2855,19 @@ els.list.addEventListener("click", (event) => {
   void loadMeeting(button.dataset.meetingId);
 });
 
+els.jobsList.addEventListener("click", (event) => {
+  if (!(event.target instanceof Element)) {
+    return;
+  }
+
+  const button = event.target.closest("[data-rerun-job-id]");
+  if (!button) {
+    return;
+  }
+
+  void rerunJob(button.dataset.rerunJobId);
+});
+
 els.refreshButton.addEventListener("click", () => {
   void refreshAll();
 });
@@ -2690,6 +3066,13 @@ const granolaWebMarkup = String.raw`
       </div>
       <p>Initial beta web client. It speaks to the same local API that future TUI and attach flows will use.</p>
     </section>
+    <section class="jobs-panel">
+      <div class="jobs-panel__head">
+        <h3>Recent Export Jobs</h3>
+        <p>Tracked across CLI and web runs.</p>
+      </div>
+      <div class="jobs-list" data-jobs-list></div>
+    </section>
     <nav class="workspace-tabs">
       <button class="workspace-tab" data-workspace-tab="notes">Notes</button>
       <button class="workspace-tab" data-workspace-tab="transcript">Transcript</button>
@@ -2912,6 +3295,90 @@ body {
   width: min(440px, 100%);
 }
 
+.jobs-panel {
+  padding: 0 24px 18px;
+}
+
+.jobs-panel__head h3 {
+  margin: 0;
+  font-size: 0.92rem;
+  letter-spacing: 0.08em;
+  text-transform: uppercase;
+}
+
+.jobs-panel__head p {
+  margin: 6px 0 0;
+  color: var(--muted);
+  font-size: 0.9rem;
+}
+
+.jobs-list {
+  display: grid;
+  gap: 10px;
+  margin-top: 14px;
+}
+
+.job-card {
+  display: grid;
+  gap: 10px;
+  padding: 14px 16px;
+  border: 1px solid var(--line);
+  border-radius: 18px;
+  background: rgba(255, 255, 255, 0.72);
+}
+
+.job-card__head {
+  display: flex;
+  flex-wrap: wrap;
+  align-items: center;
+  justify-content: space-between;
+  gap: 10px;
+}
+
+.job-card__title {
+  font-weight: 700;
+}
+
+.job-card__meta {
+  color: var(--muted);
+  font-size: 0.9rem;
+}
+
+.job-card__status {
+  padding: 6px 10px;
+  border-radius: 999px;
+  background: var(--accent-soft);
+  color: var(--accent);
+  font-size: 0.82rem;
+  font-weight: 700;
+}
+
+.job-card__status[data-status="running"] {
+  background: rgba(163, 79, 47, 0.12);
+  color: var(--warm);
+}
+
+.job-card__status[data-status="failed"] {
+  background: rgba(157, 44, 44, 0.12);
+  color: var(--error);
+}
+
+.job-card__status[data-status="completed"] {
+  background: rgba(36, 107, 79, 0.12);
+  color: var(--ok);
+}
+
+.job-card__actions {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+}
+
+.job-empty {
+  color: var(--muted);
+  font-size: 0.92rem;
+}
+
 .workspace-tabs {
   display: flex;
   flex-wrap: wrap;
@@ -3239,6 +3706,17 @@ async function startGranolaServer(app, options = {}) {
 				sendJson(response, await app.exportNotes(noteFormatFromBody(body.format)), { status: 202 });
 				return;
 			}
+			if (method === "GET" && path === "/exports/jobs") {
+				const limit = parseInteger(url.searchParams.get("limit"));
+				sendJson(response, await app.listExportJobs({ limit }));
+				return;
+			}
+			if (method === "POST" && path.startsWith("/exports/jobs/") && path.endsWith("/rerun")) {
+				const id = decodeURIComponent(path.slice(14, -6));
+				if (!id) throw new Error("export job id is required");
+				sendJson(response, await app.rerunExportJob(id), { status: 202 });
+				return;
+			}
 			if (method === "POST" && path === "/exports/transcripts") {
 				const body = await readJsonBody(request);
 				sendJson(response, await app.exportTranscripts(transcriptFormatFromBody(body.format)), { status: 202 });
@@ -3329,7 +3807,9 @@ const serveCommand = {
 		console.log("  GET  /events");
 		console.log("  GET  /meetings");
 		console.log("  GET  /meetings/:id");
+		console.log("  GET  /exports/jobs");
 		console.log("  POST /exports/notes");
+		console.log("  POST /exports/jobs/:id/rerun");
 		console.log("  POST /exports/transcripts");
 		await waitForShutdown(async () => await server.close());
 		return 0;
@@ -3375,7 +3855,7 @@ const transcriptsCommand = {
 		const app = await createGranolaApp(config);
 		debug(config.debug, "authMode", app.getState().auth.mode);
 		const result = await app.exportTranscripts(format);
-		console.log(`✓ Exported ${result.transcriptCount} transcripts to ${result.outputDir}`);
+		console.log(`✓ Exported ${result.transcriptCount} transcripts to ${result.outputDir} (job ${result.job.id})`);
 		debug(config.debug, "transcripts written", result.written);
 		return 0;
 	}
@@ -3445,6 +3925,7 @@ Options:
 //#region src/commands/index.ts
 const commands = [
 	authCommand,
+	exportsCommand,
 	meetingCommand,
 	notesCommand,
 	serveCommand,
@@ -3487,7 +3968,9 @@ const commands = [
 			console.log("  GET  /events");
 			console.log("  GET  /meetings");
 			console.log("  GET  /meetings/:id");
+			console.log("  GET  /exports/jobs");
 			console.log("  POST /exports/notes");
+			console.log("  POST /exports/jobs/:id/rerun");
 			console.log("  POST /exports/transcripts");
 			if (openBrowser) try {
 				await openExternalUrl(server.url);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "granola-toolkit",
-  "version": "0.21.1",
+  "version": "0.22.0",
   "description": "Toolkit for exporting and working with Granola meetings, notes, and transcripts",
   "keywords": [
     "cli",