@os-eco/overstory-cli 0.6.9 → 0.6.10

package/src/agents/overlay.ts

@@ -1,5 +1,6 @@
 import { mkdir } from "node:fs/promises";
 import { dirname, join, resolve } from "node:path";
+import { DEFAULT_QUALITY_GATES } from "../config.ts";
 import { AgentError } from "../errors.ts";
 import type { OverlayConfig, QualityGate } from "../types.ts";
 
@@ -76,12 +77,65 @@ Your parent has already gathered the context you need.
  * a lightweight section that only tells them to close the issue and report.
  * Writable agents get the full quality gates (tests, lint, build, commit).
  */
-/** Default quality gates used when none are configured. */
-const DEFAULT_GATES: QualityGate[] = [
-	{ name: "Tests", command: "bun test", description: "all tests must pass" },
-	{ name: "Lint", command: "bun run lint", description: "zero errors" },
-	{ name: "Typecheck", command: "bun run typecheck", description: "no TypeScript errors" },
-];
+/**
+ * Resolve quality gates: use provided gates if non-empty, otherwise fall back to defaults.
+ */
+function resolveGates(gates: QualityGate[] | undefined): QualityGate[] {
+	return gates && gates.length > 0 ? gates : DEFAULT_QUALITY_GATES;
+}
+
+/**
+ * Format quality gates as inline backtick-delimited commands for prose sections.
+ * Example: `bun test`, `bun run lint`, `bun run typecheck`
+ */
+export function formatQualityGatesInline(gates: QualityGate[] | undefined): string {
+	return resolveGates(gates)
+		.map((g) => `\`${g.command}\``)
+		.join(", ");
+}
+
+/**
+ * Format quality gates as a numbered step list for completion-protocol sections.
+ * Example:
+ *   1. Run `bun test` -- all tests must pass.
+ *   2. Run `bun run lint` -- lint and formatting must be clean.
+ */
+export function formatQualityGatesSteps(gates: QualityGate[] | undefined): string {
+	return resolveGates(gates)
+		.map((g, i) => `${i + 1}. Run \`${g.command}\` -- ${g.description}.`)
+		.join("\n");
+}
+
+/**
+ * Format quality gates as a bash code block for workflow sections.
+ * Example:
+ *   ```bash
+ *   bun test              # All tests must pass
+ *   bun run lint          # Lint and format must be clean
+ *   ```
+ */
+export function formatQualityGatesBash(gates: QualityGate[] | undefined): string {
+	const resolved = resolveGates(gates);
+	// Pad commands to align comments
+	const maxLen = Math.max(...resolved.map((g) => g.command.length));
+	const lines = resolved.map((g) => {
+		const padded = g.command.padEnd(maxLen + 2);
+		return `${padded}# ${g.description[0]?.toUpperCase() ?? ""}${g.description.slice(1)}`;
+	});
+	return ["```bash", ...lines, "```"].join("\n");
+}
+
+/**
+ * Format quality gates as a bullet list for capabilities sections.
+ * Example:
+ *   - `bun test` (run tests)
+ *   - `bun run lint` (lint and format check via biome)
+ */
+export function formatQualityGatesCapabilities(gates: QualityGate[] | undefined): string {
+	return resolveGates(gates)
+		.map((g) => `  - \`${g.command}\` (${g.description})`)
+		.join("\n");
+}
 
 function formatQualityGates(config: OverlayConfig): string {
 	if (READ_ONLY_CAPABILITIES.has(config.capability)) {
@@ -99,7 +153,9 @@ function formatQualityGates(config: OverlayConfig): string {
 	}
 
 	const gates =
-		config.qualityGates && config.qualityGates.length > 0 ? config.qualityGates : DEFAULT_GATES;
+		config.qualityGates && config.qualityGates.length > 0
+			? config.qualityGates
+			: DEFAULT_QUALITY_GATES;
 
 	const gateLines = gates.map(
 		(gate, i) => `${i + 1}. **${gate.name}:** \`${gate.command}\` — ${gate.description}`,
@@ -220,6 +276,10 @@ export async function generateOverlay(config: OverlayConfig): Promise<string> {
 		"{{SPEC_INSTRUCTION}}": specInstruction,
 		"{{SKIP_SCOUT}}": config.skipScout ? SKIP_SCOUT_SECTION : "",
 		"{{BASE_DEFINITION}}": config.baseDefinition,
+		"{{QUALITY_GATE_INLINE}}": formatQualityGatesInline(config.qualityGates),
+		"{{QUALITY_GATE_STEPS}}": formatQualityGatesSteps(config.qualityGates),
+		"{{QUALITY_GATE_BASH}}": formatQualityGatesBash(config.qualityGates),
+		"{{QUALITY_GATE_CAPABILITIES}}": formatQualityGatesCapabilities(config.qualityGates),
 		"{{TRACKER_CLI}}": config.trackerCli ?? "bd",
 		"{{TRACKER_NAME}}": config.trackerName ?? "beads",
 	};

package/src/commands/completions.test.ts

@@ -203,54 +203,42 @@ describe("completionsCommand", () => {
 	});
 
 	it("should exit with error for missing shell argument", () => {
-		const originalExit = process.exit;
+		const originalExitCode = process.exitCode;
 		const originalStderr = process.stderr.write;
-		let exitCode: number | undefined;
 		let stderrOutput = "";
 
-		process.exit = mock((code?: string | number | null | undefined) => {
-			exitCode = typeof code === "number" ? code : 1;
-			throw new Error("process.exit called");
-		}) as never;
-
 		process.stderr.write = mock((chunk: unknown) => {
 			stderrOutput += String(chunk);
 			return true;
 		});
 
 		try {
-			expect(() => completionsCommand([])).toThrow("process.exit called");
-			expect(exitCode).toBe(1);
+			completionsCommand([]);
+			expect(process.exitCode).toBe(1);
 			expect(stderrOutput).toContain("missing shell argument");
 		} finally {
-			process.exit = originalExit;
+			process.exitCode = originalExitCode;
 			process.stderr.write = originalStderr;
 		}
 	});
 
 	it("should exit with error for unknown shell", () => {
-		const originalExit = process.exit;
+		const originalExitCode = process.exitCode;
 		const originalStderr = process.stderr.write;
-		let exitCode: number | undefined;
 		let stderrOutput = "";
 
-		process.exit = mock((code?: string | number | null | undefined) => {
-			exitCode = typeof code === "number" ? code : 1;
-			throw new Error("process.exit called");
-		}) as never;
-
 		process.stderr.write = mock((chunk: unknown) => {
 			stderrOutput += String(chunk);
 			return true;
 		});
 
 		try {
-			expect(() => completionsCommand(["powershell"])).toThrow("process.exit called");
-			expect(exitCode).toBe(1);
+			completionsCommand(["powershell"]);
+			expect(process.exitCode).toBe(1);
 			expect(stderrOutput).toContain("unknown shell");
 			expect(stderrOutput).toContain("powershell");
 		} finally {
-			process.exit = originalExit;
+			process.exitCode = originalExitCode;
 			process.stderr.write = originalStderr;
 		}
 	});

package/src/commands/completions.ts

@@ -874,7 +874,8 @@ export function completionsCommand(args: string[]): void {
 
 	if (!shell) {
 		printError("missing shell argument", "Usage: ov --completions <bash|zsh|fish>");
-		process.exit(1);
+		process.exitCode = 1;
+		return;
 	}
 
 	let script: string;
@@ -890,7 +891,8 @@ export function completionsCommand(args: string[]): void {
 			break;
 		default:
 			printError(`unknown shell '${shell}'`, "Supported shells: bash, zsh, fish");
-			process.exit(1);
+			process.exitCode = 1;
+			return;
 	}
 
 	process.stdout.write(script);

package/src/commands/doctor.ts

@@ -12,6 +12,7 @@ import { checkConfig } from "../doctor/config-check.ts";
 import { checkConsistency } from "../doctor/consistency.ts";
 import { checkDatabases } from "../doctor/databases.ts";
 import { checkDependencies } from "../doctor/dependencies.ts";
+import { checkEcosystem } from "../doctor/ecosystem.ts";
 import { checkLogs } from "../doctor/logs.ts";
 import { checkMergeQueue } from "../doctor/merge-queue.ts";
 import { checkStructure } from "../doctor/structure.ts";
@@ -32,8 +33,25 @@ const ALL_CHECKS: Array<{ category: DoctorCategory; fn: DoctorCheckFn }> = [
 	{ category: "merge", fn: checkMergeQueue },
 	{ category: "logs", fn: checkLogs },
 	{ category: "version", fn: checkVersion },
+	{ category: "ecosystem", fn: checkEcosystem },
 ];
 
+/**
+ * Execute all fix functions on non-passing fixable checks.
+ * Returns a list of human-readable actions taken.
+ */
+async function applyFixes(checks: DoctorCheck[]): Promise<string[]> {
+	const fixable = checks.filter((c) => c.fixable && c.status !== "pass" && c.fix);
+	const fixed: string[] = [];
+	for (const check of fixable) {
+		if (check.fix) {
+			const actions = await check.fix();
+			fixed.push(...actions);
+		}
+	}
+	return fixed;
+}
+
 /**
  * Format human-readable output for doctor checks.
  */
@@ -41,6 +59,7 @@ function printHumanReadable(
 	checks: DoctorCheck[],
 	verbose: boolean,
 	checkRegistry: Array<{ category: DoctorCategory; fn: DoctorCheckFn }>,
+	fixedItems?: string[],
 ): void {
 	const w = process.stdout.write.bind(process.stdout);
 
@@ -105,17 +124,28 @@ function printHumanReadable(
 	w(
 		`${color.bold("Summary:")} ${color.green(`${pass} passed`)}, ${color.yellow(`${warn} warning${warn === 1 ? "" : "s"}`)}, ${color.red(`${fail} failure${fail === 1 ? "" : "s"}`)}\n`,
 	);
+
+	if (fixedItems && fixedItems.length > 0) {
+		w(`\n${color.bold("Fixed:")}\n`);
+		for (const item of fixedItems) {
+			w(`  ${color.green("-")} ${item}\n`);
+		}
+	}
 }
 
 /**
  * Format JSON output for doctor checks.
  */
-function printJSON(checks: DoctorCheck[]): void {
+function printJSON(checks: DoctorCheck[], fixed?: string[]): void {
 	const pass = checks.filter((c) => c.status === "pass").length;
 	const warn = checks.filter((c) => c.status === "warn").length;
 	const fail = checks.filter((c) => c.status === "fail").length;
 
-	jsonOutput("doctor", { checks, summary: { pass, warn, fail } });
+	jsonOutput("doctor", {
+		checks,
+		summary: { pass, warn, fail },
+		...(fixed && fixed.length > 0 ? { fixed } : {}),
+	});
 }
 
 /** Options for dependency injection in doctorCommand. */
@@ -133,59 +163,78 @@ export function createDoctorCommand(options?: DoctorCommandOptions): Command {
 		.option("--json", "Output as JSON")
 		.option("--verbose", "Show passing checks (default: only problems)")
 		.option("--category <name>", "Run only one category")
+		.option("--fix", "Attempt to auto-fix issues")
 		.addHelpText(
 			"after",
-			"\nCategories: dependencies, structure, config, databases, consistency, agents, merge, logs, version",
+			"\nCategories: dependencies, structure, config, databases, consistency, agents, merge, logs, version, ecosystem",
 		)
-		.action(async (opts: { json?: boolean; verbose?: boolean; category?: string }) => {
-			const json = opts.json ?? false;
-			const verbose = opts.verbose ?? false;
-			const categoryFilter = opts.category;
-
-			// Validate category filter if provided
-			if (categoryFilter !== undefined) {
-				const validCategories = ALL_CHECKS.map((c) => c.category);
-				if (!validCategories.includes(categoryFilter as DoctorCategory)) {
-					throw new ValidationError(
-						`Invalid category: ${categoryFilter}. Valid categories: ${validCategories.join(", ")}`,
-						{
-							field: "category",
-							value: categoryFilter,
-						},
-					);
+		.action(
+			async (opts: { json?: boolean; verbose?: boolean; category?: string; fix?: boolean }) => {
+				const json = opts.json ?? false;
+				const verbose = opts.verbose ?? false;
+				const categoryFilter = opts.category;
+				const fix = opts.fix ?? false;
+
+				// Validate category filter if provided
+				if (categoryFilter !== undefined) {
+					const validCategories = ALL_CHECKS.map((c) => c.category);
+					if (!validCategories.includes(categoryFilter as DoctorCategory)) {
+						throw new ValidationError(
+							`Invalid category: ${categoryFilter}. Valid categories: ${validCategories.join(", ")}`,
+							{
+								field: "category",
+								value: categoryFilter,
+							},
+						);
+					}
 				}
-			}
 
-			const cwd = process.cwd();
-			const config = await loadConfig(cwd);
-			const overstoryDir = join(config.project.root, ".overstory");
-
-			// Filter checks by category if specified
-			const allChecks = options?.checkRunners ?? ALL_CHECKS;
-			const checksToRun = categoryFilter
-				? allChecks.filter((c) => c.category === categoryFilter)
-				: allChecks;
-
-			// Run all checks sequentially
-			const results: DoctorCheck[] = [];
-			for (const { fn } of checksToRun) {
-				const checkResults = await fn(config, overstoryDir);
-				results.push(...checkResults);
-			}
+				const cwd = process.cwd();
+				const config = await loadConfig(cwd);
+				const overstoryDir = join(config.project.root, ".overstory");
 
-			// Output results
-			if (json) {
-				printJSON(results);
-			} else {
-				printHumanReadable(results, verbose, allChecks);
-			}
+				// Filter checks by category if specified
+				const allChecks = options?.checkRunners ?? ALL_CHECKS;
+				const checksToRun = categoryFilter
+					? allChecks.filter((c) => c.category === categoryFilter)
+					: allChecks;
 
-			// Set exit code if any check failed
-			const hasFailures = results.some((c) => c.status === "fail");
-			if (hasFailures) {
-				process.exitCode = 1;
-			}
-		});
+				// Run all checks sequentially
+				let results: DoctorCheck[] = [];
+				for (const { fn } of checksToRun) {
+					const checkResults = await fn(config, overstoryDir);
+					results.push(...checkResults);
+				}
+
+				// Apply fixes if requested
+				let fixedItems: string[] | undefined;
+				if (fix) {
+					const applied = await applyFixes(results);
+					if (applied.length > 0) {
+						fixedItems = applied;
+						// Re-run all checks to get fresh results after fixes
+						results = [];
+						for (const { fn } of checksToRun) {
+							const checkResults = await fn(config, overstoryDir);
+							results.push(...checkResults);
+						}
+					}
+				}
+
+				// Output results
+				if (json) {
+					printJSON(results, fixedItems);
+				} else {
+					printHumanReadable(results, verbose, allChecks, fixedItems);
+				}
+
+				// Set exit code if any check failed
+				const hasFailures = results.some((c) => c.status === "fail");
+				if (hasFailures) {
+					process.exitCode = 1;
+				}
+			},
+		);
 }
 
 /**

package/src/commands/ecosystem.ts

@@ -0,0 +1,291 @@
+/**
+ * CLI command: ov ecosystem
+ *
+ * Shows a summary dashboard of all installed os-eco tools: version, update
+ * status (latest vs outdated), and doctor health (overstory only).
+ */
+
+import { Command } from "commander";
+import { jsonError, jsonOutput } from "../json.ts";
+import { accent, brand, color, muted } from "../logging/color.ts";
+
+const TOOLS = [
+	{ name: "overstory", cli: "ov", npm: "@os-eco/overstory-cli" },
+	{ name: "mulch", cli: "ml", npm: "@os-eco/mulch-cli" },
+	{ name: "seeds", cli: "sd", npm: "@os-eco/seeds-cli" },
+	{ name: "canopy", cli: "cn", npm: "@os-eco/canopy-cli" },
+] as const;
+
+export interface EcosystemOptions {
+	json?: boolean;
+}
+
+interface DoctorSummary {
+	pass: number;
+	warn: number;
+	fail: number;
+}
+
+interface ToolResult {
+	name: string;
+	cli: string;
+	npm: string;
+	installed: boolean;
+	version?: string;
+	latest?: string;
+	upToDate?: boolean;
+	doctorSummary?: DoctorSummary;
+	latestError?: string;
+}
+
+async function getInstalledVersion(cli: string): Promise<string | null> {
+	// Try --version --json first
+	try {
+		const proc = Bun.spawn([cli, "--version", "--json"], {
+			stdout: "pipe",
+			stderr: "pipe",
+		});
+		const exitCode = await proc.exited;
+		if (exitCode === 0) {
+			const stdout = await new Response(proc.stdout).text();
+			try {
+				const data = JSON.parse(stdout.trim()) as { version?: string };
+				if (data.version) return data.version;
+			} catch {
+				// Not valid JSON, fall through to plain text
+			}
+		}
+	} catch {
+		// CLI not found — fall through to plain text fallback
+	}
+
+	// Fallback: --version plain text
+	try {
+		const proc = Bun.spawn([cli, "--version"], {
+			stdout: "pipe",
+			stderr: "pipe",
+		});
+		const exitCode = await proc.exited;
+		if (exitCode === 0) {
+			const stdout = await new Response(proc.stdout).text();
+			const match = stdout.match(/(\d+\.\d+\.\d+)/);
+			if (match?.[1]) return match[1];
+		}
+	} catch {
+		// CLI not found
+	}
+
+	return null;
+}
+
+async function fetchLatestVersion(packageName: string): Promise<string> {
+	const res = await fetch(`https://registry.npmjs.org/${packageName}/latest`);
+	if (!res.ok) {
+		throw new Error(`npm registry error: ${res.status} ${res.statusText}`);
+	}
+	const data = (await res.json()) as { version: string };
+	return data.version;
+}
+
+async function getDoctorSummary(): Promise<DoctorSummary | undefined> {
+	try {
+		const proc = Bun.spawn(["ov", "doctor", "--json"], {
+			stdout: "pipe",
+			stderr: "pipe",
+		});
+		await proc.exited;
+		const stdout = await new Response(proc.stdout).text();
+		const trimmed = stdout.trim();
+		if (trimmed) {
+			const data = JSON.parse(trimmed) as {
+				summary?: { pass?: number; warn?: number; fail?: number };
+			};
+			if (data.summary) {
+				return {
+					pass: data.summary.pass ?? 0,
+					warn: data.summary.warn ?? 0,
+					fail: data.summary.fail ?? 0,
+				};
+			}
+		}
+	} catch {
+		// Doctor failed — report nothing
+	}
+	return undefined;
+}
+
+async function checkTool(tool: { name: string; cli: string; npm: string }): Promise<ToolResult> {
+	const version = await getInstalledVersion(tool.cli);
+
+	if (version === null) {
+		return { name: tool.name, cli: tool.cli, npm: tool.npm, installed: false };
+	}
+
+	let latest: string | undefined;
+	let latestError: string | undefined;
+	let doctorSummary: DoctorSummary | undefined;
+
+	const latestPromise = fetchLatestVersion(tool.npm)
+		.then((v) => {
+			latest = v;
+		})
+		.catch((err) => {
+			latestError = err instanceof Error ? err.message : String(err);
+		});
+
+	const doctorPromise =
+		tool.name === "overstory"
+			? getDoctorSummary().then((d) => {
+					doctorSummary = d;
+				})
+			: Promise.resolve();
+
+	await Promise.all([latestPromise, doctorPromise]);
+
+	const upToDate = latest !== undefined ? version === latest : undefined;
+
+	return {
+		name: tool.name,
+		cli: tool.cli,
+		npm: tool.npm,
+		installed: true,
+		version,
+		latest,
+		upToDate,
+		doctorSummary,
+		latestError,
+	};
+}
+
+function formatDoctorLine(summary: DoctorSummary): string {
+	const parts: string[] = [];
+	if (summary.pass > 0) parts.push(color.green(`${summary.pass} passed`));
+	if (summary.warn > 0) parts.push(color.yellow(`${summary.warn} warn`));
+	if (summary.fail > 0) parts.push(color.red(`${summary.fail} fail`));
+	return parts.length > 0 ? parts.join(", ") : "no checks";
+}
+
+function printHumanOutput(results: ToolResult[]): void {
+	process.stdout.write(`${brand.bold("os-eco Ecosystem")}\n`);
+	process.stdout.write(`${"═".repeat(60)}\n`);
+	process.stdout.write("\n");
+
+	for (const tool of results) {
+		if (!tool.installed) {
+			process.stdout.write(
+				`  ${color.red("x")} ${accent(tool.name)} ${muted(`(${tool.cli})`)}  ${color.red("not installed")}\n`,
+			);
+			process.stdout.write(`    ${muted(`npm i -g ${tool.npm}`)}\n`);
+			process.stdout.write("\n");
+			continue;
+		}
+
+		// Determine status icon
+		let icon: string;
+		if (tool.latestError !== undefined || tool.upToDate === undefined) {
+			icon = muted("-");
+		} else if (tool.upToDate) {
+			icon = color.green("-");
+		} else {
+			icon = color.yellow("!");
+		}
+
+		process.stdout.write(`  ${icon} ${accent(tool.name)} ${muted(`(${tool.cli})`)}\n`);
+
+		// Version line
+		let versionLine = `Version: ${tool.version}`;
+		if (tool.latestError !== undefined) {
+			versionLine += ` ${muted("(version check failed)")}`;
+		} else if (tool.upToDate === true) {
+			versionLine += ` ${color.green("(up to date)")}`;
+		} else if (tool.upToDate === false) {
+			versionLine += ` ${color.yellow(`(outdated, latest: ${tool.latest})`)}`;
+		}
+		process.stdout.write(`    ${versionLine}\n`);
+
+		// Doctor summary (overstory only)
+		if (tool.doctorSummary !== undefined) {
+			process.stdout.write(`    Doctor:  ${formatDoctorLine(tool.doctorSummary)}\n`);
+		}
+
+		process.stdout.write("\n");
+	}
+
+	const installed = results.filter((t) => t.installed).length;
+	const missing = results.filter((t) => !t.installed).length;
+	const outdated = results.filter(
+		(t) => t.installed && t.upToDate === false && t.latestError === undefined,
+	).length;
+
+	let summary = `Summary: ${installed}/${results.length} installed`;
+	if (missing > 0) summary += `, ${missing} missing`;
+	if (outdated > 0) summary += `, ${outdated} outdated`;
+	process.stdout.write(`${summary}\n`);
+}
+
+export async function executeEcosystem(opts: EcosystemOptions): Promise<void> {
+	const json = opts.json ?? false;
+
+	let results: ToolResult[];
+	try {
+		results = await Promise.all(TOOLS.map((tool) => checkTool(tool)));
+	} catch (err) {
+		const msg = err instanceof Error ? err.message : String(err);
+		if (json) {
+			jsonError("ecosystem", msg);
+		} else {
+			process.stderr.write(`Error: ${msg}\n`);
+		}
+		process.exitCode = 1;
+		return;
+	}
+
+	if (json) {
+		const installed = results.filter((t) => t.installed).length;
+		const missing = results.filter((t) => !t.installed).length;
+		const outdated = results.filter(
+			(t) => t.installed && t.upToDate === false && t.latestError === undefined,
+		).length;
+
+		jsonOutput("ecosystem", {
+			tools: results.map((t) => {
+				const entry: Record<string, unknown> = {
+					name: t.name,
+					cli: t.cli,
+					npm: t.npm,
+					installed: t.installed,
+				};
+				if (t.installed) {
+					entry.version = t.version;
+					entry.latest = t.latest;
+					entry.upToDate = t.upToDate;
+					if (t.doctorSummary !== undefined) {
+						entry.doctorSummary = t.doctorSummary;
+					}
+					if (t.latestError !== undefined) {
+						entry.latestError = t.latestError;
+					}
+				}
+				return entry;
+			}),
+			summary: {
+				total: results.length,
+				installed,
+				missing,
+				outdated,
+			},
+		});
+		return;
+	}
+
+	printHumanOutput(results);
+}
+
+export function createEcosystemCommand(): Command {
+	return new Command("ecosystem")
+		.description("Show a summary dashboard of all installed os-eco tools")
+		.option("--json", "Output as JSON")
+		.action(async (opts: EcosystemOptions) => {
+			await executeEcosystem(opts);
+		});
+}

package/src/commands/feed.ts

@@ -264,7 +264,7 @@ async function executeFeed(opts: FeedOpts): Promise<void> {
 		} else {
 			// JSON mode: print each event as a line
 			for (const event of initialEvents) {
-				process.stdout.write(`${JSON.stringify(event)}\n`);
+				jsonOutput("feed", { event });
 			}
 			if (initialEvents.length > 0) {
 				const lastEvent = initialEvents[initialEvents.length - 1];
@@ -308,7 +308,7 @@ async function executeFeed(opts: FeedOpts): Promise<void> {
 				} else {
 					// JSON mode: print each event as a line
 					for (const event of newEvents) {
-						process.stdout.write(`${JSON.stringify(event)}\n`);
+						jsonOutput("feed", { event });
 					}
 				}