@ricky-stevens/context-guardian 2.1.0 → 2.2.0

package/lib/statusline.mjs

@@ -25,6 +25,7 @@ process.stdin.on("error", () => {
 process.stdin.on("end", () => {
 	try {
 		const data = JSON.parse(raw);
+		persistSessionMetadata(data);
 		process.stdout.write(render(data));
 	} catch {
 		process.stdout.write("Context: --");
@@ -32,38 +33,118 @@ process.stdin.on("end", () => {
 });
 
 /**
- * Render the statusline output from Claude Code's session data.
- *
- * Claude Code pipes JSON with this structure:
- *   context_window: { used_percentage, remaining_percentage, total_input_tokens, total_output_tokens }
- *   model: { id, display_name }
+ * Persist authoritative session metadata from Claude Code's statusline JSON
+ * into the per-session state file. The statusline is the only CG component
+ * that receives these values directly from CC. Hooks read them from here.
  */
-function render(data) {
-	const pctRaw = data.context_window?.used_percentage;
-	if (pctRaw == null) {
-		const dim = "\x1b[2m";
-		const reset = "\x1b[0m";
-		return `${dim}Context usage: --${reset}`;
-	}
+function persistSessionMetadata(data) {
+	const size = data.context_window?.context_window_size;
+	const modelId = data.model?.id;
+	const sessionId = data.session_id;
+	if (!sessionId || (typeof size !== "number" && !modelId)) return;
+	try {
+		const dir = path.join(os.homedir(), ".claude", "cg");
+		fs.mkdirSync(dir, { recursive: true });
+		const filePath = path.join(dir, `state-${sessionId}.json`);
 
-	const pct = Math.round(pctRaw);
+		// Read-modify-write: merge CC-provided values into existing state.
+		// Skip the write if nothing changed — minimises race window with hooks.
+		let state = {};
+		try {
+			state = JSON.parse(fs.readFileSync(filePath, "utf8"));
+		} catch {}
 
-	// Read threshold from config if available, fallback to 35%
+		let changed = false;
+		if (
+			typeof size === "number" &&
+			size > 0 &&
+			state.context_window_size !== size
+		) {
+			state.context_window_size = size;
+			changed = true;
+		}
+		if (modelId && state.cc_model_id !== modelId) {
+			state.cc_model_id = modelId;
+			changed = true;
+		}
+		if (!changed) return;
+
+		const rand = Math.random().toString(36).slice(2, 10);
+		const tmp = `${filePath}.${process.pid}.${Date.now()}.${rand}.tmp`;
+		fs.writeFileSync(tmp, JSON.stringify(state));
+		fs.renameSync(tmp, filePath);
+	} catch {}
+}
+
+// ---------------------------------------------------------------------------
+// Threshold resolution — adaptive based on context window size, with
+// user-configured override. Same formula as computeAdaptiveThreshold in
+// config.mjs: 55% at 200K, 30% at 1M, clamped [25%, 55%].
+// ---------------------------------------------------------------------------
+function resolveThreshold(data) {
 	const dataDir =
 		process.env.CLAUDE_PLUGIN_DATA || path.join(os.homedir(), ".claude", "cg");
-	let threshold = 35;
 	try {
 		const configPath = path.join(dataDir, "config.json");
 		if (fs.existsSync(configPath)) {
 			const cfg = JSON.parse(fs.readFileSync(configPath, "utf8"));
-			if (cfg.threshold) threshold = Math.round(cfg.threshold * 100);
+			if ("threshold" in cfg) return Math.round(cfg.threshold * 100);
 		}
 	} catch {}
+	const windowSize = data.context_window?.context_window_size || 200000;
+	const adaptive = Math.min(
+		0.55,
+		Math.max(0.25, 0.55 - ((windowSize - 200000) * 0.25) / 800000),
+	);
+	return Math.round(adaptive * 100);
+}
+
+// ---------------------------------------------------------------------------
+// Session size — reads the most recent state file from the data dir to get
+// payload_bytes and baseline_overhead for the ~20MB API limit display.
+// ---------------------------------------------------------------------------
+function readSessionSize(dataDir) {
+	const stateFiles = fs
+		.readdirSync(dataDir)
+		.filter((f) => f.startsWith("state-") && f.endsWith(".json"));
+	if (stateFiles.length === 0) return 0;
+
+	let newest = stateFiles[0];
+	let newestMtime = 0;
+	for (const f of stateFiles) {
+		const mt = fs.statSync(path.join(dataDir, f)).mtimeMs;
+		if (mt > newestMtime) {
+			newestMtime = mt;
+			newest = f;
+		}
+	}
+	const state = JSON.parse(fs.readFileSync(path.join(dataDir, newest), "utf8"));
+	const overheadBytes = (state.baseline_overhead || 0) * 4;
+	return (state.payload_bytes || 0) + overheadBytes;
+}
+
+// ---------------------------------------------------------------------------
+// Color-coded session size string.
+// ---------------------------------------------------------------------------
+function formatSessionSize(totalBytes, dim, reset) {
+	if (totalBytes <= 0) return `${dim}--${reset}`;
+	const mb = Math.max(0.1, totalBytes / (1024 * 1024)).toFixed(1);
+	if (mb >= 15) return `\x1b[1;31mSession size: ${mb}/20MB${reset}`;
+	const numColor = mb < 10 ? "\x1b[32m" : "\x1b[33m";
+	return `${dim}Session size:${reset} ${numColor}${mb}${dim}/20MB${reset}`;
+}
 
-	// Color strategy:
-	// - Green: labels dim/grey, only numbers colored green
-	// - Yellow: labels dim/grey, only numbers colored yellow
-	// - Red: entire label+number is bold red (maximum visibility)
+/**
+ * Render the statusline output from Claude Code's session data.
+ */
+function render(data) {
+	const pctRaw = data.context_window?.used_percentage;
+	if (pctRaw == null) {
+		return "\x1b[2mContext usage: --\x1b[0m";
+	}
+
+	const pct = Math.round(pctRaw);
+	const threshold = resolveThreshold(data);
 	const reset = "\x1b[0m";
 	const dim = "\x1b[2m";
 
@@ -75,42 +156,11 @@ function render(data) {
 		contextStr = `${dim}Context usage:${reset} ${numColor}${pct}%${reset}`;
 	}
 
-	// Session size — proxy for the ~20MB API request limit (separate from token limit).
-	// Read from the most recent state file written by submit/stop hooks.
+	const dataDir =
+		process.env.CLAUDE_PLUGIN_DATA || path.join(os.homedir(), ".claude", "cg");
 	let sessionStr = `${dim}--${reset}`;
 	try {
-		const stateFiles = fs
-			.readdirSync(dataDir)
-			.filter((f) => f.startsWith("state-") && f.endsWith(".json"));
-		if (stateFiles.length > 0) {
-			// Pick the most recently modified state file
-			let newest = stateFiles[0];
-			let newestMtime = 0;
-			for (const f of stateFiles) {
-				const mt = fs.statSync(path.join(dataDir, f)).mtimeMs;
-				if (mt > newestMtime) {
-					newestMtime = mt;
-					newest = f;
-				}
-			}
-			const state = JSON.parse(
-				fs.readFileSync(path.join(dataDir, newest), "utf8"),
-			);
-			// Total payload = transcript file + system overhead (prompts, tools, CLAUDE.md).
-			// The transcript JSONL only contains conversation messages, not the full
-			// API request. baseline_overhead (tokens) × 4 ≈ system overhead in bytes.
-			const overheadBytes = (state.baseline_overhead || 0) * 4;
-			const totalBytes = (state.payload_bytes || 0) + overheadBytes;
-			if (totalBytes > 0) {
-				const mb = Math.max(0.1, totalBytes / (1024 * 1024)).toFixed(1);
-				if (mb >= 15) {
-					sessionStr = `\x1b[1;31mSession size: ${mb}/20MB${reset}`;
-				} else {
-					const numColor = mb < 10 ? "\x1b[32m" : "\x1b[33m";
-					sessionStr = `${dim}Session size:${reset} ${numColor}${mb}${dim}/20MB${reset}`;
-				}
-			}
-		}
+		sessionStr = formatSessionSize(readSessionSize(dataDir), dim, reset);
 	} catch {}
 
 	const untilAlert = Math.max(0, threshold - pct);

package/lib/tokens.mjs

@@ -59,23 +59,9 @@ function _findUsage(lines) {
 				const cacheRead = usage.cache_read_input_tokens || 0;
 				const output = usage.output_tokens || 0;
 
-				// Detect max_tokens from model name in the same message.
-				// Only Opus 4.6+ has 1M tokens. Format: "claude-opus-4-6"
-				const model = (obj.message?.model || "").toLowerCase();
-				let max_tokens = 200000; // default for all Sonnet/Haiku/older Opus
-				const opusMatch = model.match(/opus[- ]?(\d+)[- .]?(\d+)?/);
-				if (opusMatch) {
-					const major = Number.parseInt(opusMatch[1], 10);
-					const minor = Number.parseInt(opusMatch[2] || "0", 10);
-					if (major > 4 || (major === 4 && minor >= 6)) {
-						max_tokens = 1000000;
-					}
-				}
-
 				return {
 					current_tokens: inputTokens + cacheCreate + cacheRead,
 					output_tokens: output,
-					max_tokens,
 					model: obj.message?.model || "unknown",
 				};
 			}
@@ -142,8 +128,8 @@ export function estimateTokens(transcriptPath) {
 // Session overhead estimation — tokens from system prompt, tool definitions,
 // memory files, and skills that survive compaction unchanged.
 // Uses transcript file size / 4 to estimate conversation tokens, then
-// subtracts from real token count. Both estimate.mjs and checkpoint.mjs
-// use this for consistent predictions.
+// subtracts from real token count. Used by checkpoint.mjs and handoff.mjs
+// for post-compaction stats.
 // ---------------------------------------------------------------------------
 export function estimateOverhead(
 	currentTokens,

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@ricky-stevens/context-guardian",
-	"version": "2.1.0",
+	"version": "2.2.0",
 	"description": "Automatic context window monitoring and smart compaction for Claude Code",
 	"author": "Ricky Stevens",
 	"license": "MIT",

package/skills/config/SKILL.md

@@ -15,7 +15,7 @@ If `${CLAUDE_PLUGIN_DATA}` is empty, use `~/.claude/cg/config.json`.
 
 If `$ARGUMENTS` is empty, read these files:
 
-1. `${CLAUDE_PLUGIN_DATA}/config.json` (may not exist — defaults: threshold 0.35, max_tokens 200000)
+1. `${CLAUDE_PLUGIN_DATA}/config.json` (may not exist — threshold is adaptive based on context window size, max_tokens defaults to 200000)
 2. `${CLAUDE_PLUGIN_DATA}/state-${CLAUDE_SESSION_ID}.json` (may not exist)
 
 If the state file exists and has a `model` field, display:

package/skills/stats/SKILL.md

@@ -29,25 +29,13 @@ If the file does not exist, display this and stop:
 └─────────────────────────────────────────────────
 ```
 
-## Step 2 — Compute "Last updated"
-
-Run: `echo $(( $(date +%s) - JSON_TS_VALUE / 1000 ))`
-
-Replace `JSON_TS_VALUE` with the `ts` field from the JSON. The command outputs the age in seconds. Display it as:
-- Under 60: "Xs ago"
-- 60–3599: "Xm ago"
-- 3600+: "Xh ago"
-
-If the result is greater than 300, append " (stale)".
-
-## Step 3 — Display the status box
+## Step 2 — Display the status box
 
 All values come directly from the JSON — use them as-is. Do NOT compute any values yourself.
 
 - `pct_display` — already a string like "2.5"
 - `threshold_display` — already a number like 35
 - `remaining_to_alert` — already computed (threshold minus current, rounded)
-- `smart_estimate_pct` and `recent_estimate_pct` — already computed
 
 ```
 ┌─────────────────────────────────────────────────
@@ -56,33 +44,24 @@ All values come directly from the JSON — use them as-is. Do NOT compute any va
 │  Current usage:   {current_tokens with commas} / {max_tokens with commas} tokens ({pct_display}%)
 │  Session size:    {(payload_bytes + baseline_overhead × 4) ÷ 1048576, to 1 decimal, minimum 0.1}MB / 20MB
 │  Threshold:       {threshold_display}% ({remaining_to_alert}% remaining to alert)
-│  Data source:     {source: "real" → "real counts", "estimated" → "estimated"}
-│
 │  Model:           {model} / {max_tokens with commas} tokens
-│  Last updated:    {computed from Step 2}
 │
-│  /cg:compact         ~{pct_display}% → ~{smart_estimate_pct}%
-│  /cg:prune           ~{pct_display}% → ~{recent_estimate_pct}%
-│
-│  /cg:handoff [name]  save session for later
+│  /cg:compact        smart compact — strips file reads, system noise
+│  /cg:prune          keep last 10 exchanges only
+│  /cg:handoff [name] save session for later
 │
 └─────────────────────────────────────────────────
 ```
 
-## Step 4 — Run diagnostics (optional)
+## Step 3 — Run diagnostics
 
 Run: `node ${CLAUDE_PLUGIN_ROOT}/lib/diagnostics.mjs ${CLAUDE_SESSION_ID} ${CLAUDE_PLUGIN_ROOT} ${CLAUDE_PLUGIN_DATA}`
 
 If the command fails or returns invalid JSON, omit the Health section entirely.
 
-Parse the JSON output. If **all** checks have `ok: true`, append this line inside the box before the closing `└`:
-
-```
-│
-│  Health:          All checks passed
-```
+Parse the JSON output. If **all** checks have `ok: true`, do NOT add a Health section.
 
-If **any** check has `ok: false`, append this instead:
+If **any** check has `ok: false`, append this inside the box before the closing `└`:
 
 ```
 │

package/test/checkpoint.test.mjs

@@ -60,8 +60,8 @@ describe("writeCompactionState", () => {
 		assert.equal(state.transcript_path, "/tmp/transcript.jsonl");
 		assert.equal(state.session_id, "sess1");
 		assert.equal(state.model, "unknown");
-		assert.equal(state.smart_estimate_pct, 0);
-		assert.equal(state.recent_estimate_pct, 0);
+		assert.equal(state.smart_estimate_pct, undefined);
+		assert.equal(state.recent_estimate_pct, undefined);
 		assert.equal(typeof state.ts, "number");
 	});
 

package/test/config.test.mjs

@@ -0,0 +1,39 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { computeAdaptiveThreshold } from "../lib/config.mjs";
+
+describe("computeAdaptiveThreshold", () => {
+	it("returns 0.55 for 200K window", () => {
+		assert.equal(computeAdaptiveThreshold(200000), 0.55);
+	});
+
+	it("returns 0.30 for 1M window (lower bound area)", () => {
+		const result = computeAdaptiveThreshold(1000000);
+		assert.ok(
+			result >= 0.25 && result <= 0.31,
+			`expected ~0.30, got ${result}`,
+		);
+	});
+
+	it("returns intermediate value for 500K window", () => {
+		const result = computeAdaptiveThreshold(500000);
+		assert.ok(result > 0.3 && result < 0.55, `expected ~0.46, got ${result}`);
+	});
+
+	it("clamps to 0.55 for windows smaller than 200K", () => {
+		assert.equal(computeAdaptiveThreshold(100000), 0.55);
+	});
+
+	it("clamps to 0.25 for very large windows", () => {
+		assert.equal(computeAdaptiveThreshold(5000000), 0.25);
+	});
+
+	it("scales linearly between 200K and 1M", () => {
+		const at200k = computeAdaptiveThreshold(200000);
+		const at600k = computeAdaptiveThreshold(600000);
+		const at1m = computeAdaptiveThreshold(1000000);
+		// Should decrease monotonically
+		assert.ok(at200k > at600k, "200K threshold should be higher than 600K");
+		assert.ok(at600k > at1m, "600K threshold should be higher than 1M");
+	});
+});

package/test/integration.test.mjs

@@ -56,7 +56,10 @@ function runHook(input) {
 			input: stdin,
 			encoding: "utf8",
 			timeout: 5000,
-			env: { ...process.env, CLAUDE_PLUGIN_DATA: dataDir },
+			env: {
+				...process.env,
+				CLAUDE_PLUGIN_DATA: dataDir,
+			},
 		});
 		return stdout ? JSON.parse(stdout) : null;
 	} catch (e) {

package/test/statusline.test.mjs

@@ -109,14 +109,16 @@ describe("threshold-relative colors", () => {
 	});
 
 	it("approaching threshold: dim label, yellow number", () => {
-		const raw = runStatusline({ context_window: { used_percentage: 30 } });
+		// Default adaptive threshold for 200K is 55%, yellow starts at 55*0.7=38.5%
+		const raw = runStatusline({ context_window: { used_percentage: 45 } });
 		assert.ok(raw.includes("\x1b[2mContext usage:\x1b[0m")); // dim label
-		assert.ok(raw.includes("\x1b[33m30%")); // yellow number
+		assert.ok(raw.includes("\x1b[33m45%")); // yellow number
 	});
 
 	it("at threshold: bold red on entire label+number", () => {
-		const raw = runStatusline({ context_window: { used_percentage: 40 } });
-		assert.ok(raw.includes("\x1b[1;31mContext usage: 40%")); // bold red full
+		// Default adaptive threshold for 200K is 55%
+		const raw = runStatusline({ context_window: { used_percentage: 60 } });
+		assert.ok(raw.includes("\x1b[1;31mContext usage: 60%")); // bold red full
 	});
 
 	it("colors adjust with custom threshold", () => {
@@ -138,6 +140,26 @@ describe("threshold-relative colors", () => {
 		);
 		assert.ok(redRaw.includes("\x1b[1;31mContext usage: 75%"));
 	});
+
+	it("adaptive threshold: 1M window uses lower threshold than 200K", () => {
+		// 1M adaptive threshold = 30%, so 25% is yellow (above 30*0.7=21%)
+		const yellowRaw = runStatusline({
+			context_window: { used_percentage: 25, context_window_size: 1000000 },
+		});
+		assert.ok(yellowRaw.includes("\x1b[33m25%")); // yellow
+
+		// 35% is red on 1M (above 30% threshold)
+		const redRaw = runStatusline({
+			context_window: { used_percentage: 35, context_window_size: 1000000 },
+		});
+		assert.ok(redRaw.includes("\x1b[1;31mContext usage: 35%")); // bold red
+
+		// Same 35% on 200K is green (below 55*0.7=38.5%)
+		const greenRaw = runStatusline({
+			context_window: { used_percentage: 35, context_window_size: 200000 },
+		});
+		assert.ok(greenRaw.includes("\x1b[32m35%")); // green
+	});
 });
 
 describe("session size display", () => {
@@ -198,17 +220,105 @@ describe("session size display", () => {
 	});
 });
 
+describe("context window size persistence", () => {
+	const stateDir = path.join(os.homedir(), ".claude", "cg");
+
+	it("writes context_window_size into per-session state file", () => {
+		const sessionId = `sl-test-${Date.now()}`;
+		const stateFile = path.join(stateDir, `state-${sessionId}.json`);
+		try {
+			runStatusline({
+				session_id: sessionId,
+				context_window: {
+					used_percentage: 10,
+					context_window_size: 1000000,
+				},
+			});
+
+			assert.ok(fs.existsSync(stateFile), "state file should exist");
+			const data = JSON.parse(fs.readFileSync(stateFile, "utf8"));
+			assert.equal(data.context_window_size, 1000000);
+		} finally {
+			try {
+				fs.unlinkSync(stateFile);
+			} catch {}
+		}
+	});
+
+	it("merges context_window_size into existing state file", () => {
+		const sessionId = `sl-test-${Date.now()}`;
+		const stateFile = path.join(stateDir, `state-${sessionId}.json`);
+		try {
+			// Pre-populate state file (as a hook would)
+			fs.mkdirSync(stateDir, { recursive: true });
+			fs.writeFileSync(
+				stateFile,
+				JSON.stringify({ current_tokens: 5000, max_tokens: 200000 }),
+			);
+
+			runStatusline({
+				session_id: sessionId,
+				context_window: {
+					used_percentage: 10,
+					context_window_size: 1000000,
+				},
+			});
+
+			const data = JSON.parse(fs.readFileSync(stateFile, "utf8"));
+			assert.equal(data.context_window_size, 1000000);
+			assert.equal(data.current_tokens, 5000); // preserved
+		} finally {
+			try {
+				fs.unlinkSync(stateFile);
+			} catch {}
+		}
+	});
+
+	it("does not write when context_window_size is missing", () => {
+		const sessionId = `sl-test-nowrite-${Date.now()}`;
+		const stateFile = path.join(stateDir, `state-${sessionId}.json`);
+		try {
+			runStatusline({
+				session_id: sessionId,
+				context_window: { used_percentage: 10 },
+			});
+
+			assert.equal(fs.existsSync(stateFile), false);
+		} finally {
+			try {
+				fs.unlinkSync(stateFile);
+			} catch {}
+		}
+	});
+
+	it("does not write when session_id is missing", () => {
+		// Without session_id, we can't target a state file
+		// Just verify no crash — the render output should still work
+		const out = strip(
+			runStatusline({
+				context_window: {
+					used_percentage: 10,
+					context_window_size: 1000000,
+				},
+			}),
+		);
+		assert.ok(out.includes("10%"));
+	});
+});
+
 describe("alert state messaging", () => {
 	it("at threshold shows actionable compaction message", () => {
+		// Default adaptive threshold for 200K is 55%
 		const out = strip(
-			runStatusline({ context_window: { used_percentage: 40 } }),
+			runStatusline({ context_window: { used_percentage: 60 } }),
 		);
 		assert.ok(out.includes("compaction recommended"));
 		assert.ok(out.includes("/cg:compact"));
 	});
 
 	it("at threshold uses bold red for alert text", () => {
-		const raw = runStatusline({ context_window: { used_percentage: 40 } });
+		// Default adaptive threshold for 200K is 55%
+		const raw = runStatusline({ context_window: { used_percentage: 60 } });
 		assert.ok(raw.includes("\x1b[1;31mcompaction recommended"));
 	});
 

package/test/submit.test.mjs

@@ -135,7 +135,7 @@ describe("token state writing", () => {
 		assert.ok(state.recommendation.includes("All clear"));
 	});
 
-	it("includes savings estimates in state", () => {
+	it("does not include savings estimates in state (removed — inaccurate)", () => {
 		writeLine(makeUser("hello"));
 		writeLine(makeAssistant("hi", HIGH_USAGE));
 
@@ -143,14 +143,8 @@ describe("token state writing", () => {
 
 		const sf = path.join(dataDir, "state-test-session-1234.json");
 		const state = JSON.parse(fs.readFileSync(sf, "utf8"));
-		assert.ok(
-			state.smart_estimate_pct != null,
-			"smart_estimate_pct should exist",
-		);
-		assert.ok(
-			state.recent_estimate_pct != null,
-			"recent_estimate_pct should exist",
-		);
+		assert.equal(state.smart_estimate_pct, undefined);
+		assert.equal(state.recent_estimate_pct, undefined);
 	});
 });
 

package/test/tokens.test.mjs

@@ -100,7 +100,7 @@ describe("getTokenUsage", () => {
 		assert.equal(result.current_tokens, 350); // 200 + 100 + 50
 	});
 
-	it("detects Opus 4.6+ as 1M context", () => {
+	it("does not include max_tokens (callers resolve from state file)", () => {
 		writeLine(makeUserMessage("hello"));
 		writeLine(
 			makeAssistantMessage(
@@ -116,48 +116,10 @@ describe("getTokenUsage", () => {
 		);
 
 		const result = getTokenUsage(transcriptPath);
-		assert.equal(result.max_tokens, 1000000);
+		assert.equal(result.max_tokens, undefined);
 		assert.equal(result.model, "claude-opus-4-6-20260101");
 	});
 
-	it("detects Sonnet as 200K context", () => {
-		writeLine(makeUserMessage("hello"));
-		writeLine(
-			makeAssistantMessage(
-				"hi",
-				{
-					input_tokens: 100,
-					cache_creation_input_tokens: 0,
-					cache_read_input_tokens: 0,
-					output_tokens: 10,
-				},
-				"claude-sonnet-4-20250514",
-			),
-		);
-
-		const result = getTokenUsage(transcriptPath);
-		assert.equal(result.max_tokens, 200000);
-	});
-
-	it("detects future Opus 5.x as 1M context", () => {
-		writeLine(makeUserMessage("hello"));
-		writeLine(
-			makeAssistantMessage(
-				"hi",
-				{
-					input_tokens: 100,
-					cache_creation_input_tokens: 0,
-					cache_read_input_tokens: 0,
-					output_tokens: 10,
-				},
-				"claude-opus-5-0",
-			),
-		);
-
-		const result = getTokenUsage(transcriptPath);
-		assert.equal(result.max_tokens, 1000000);
-	});
-
 	it("handles zero usage values", () => {
 		writeLine(makeUserMessage("hello"));
 		writeLine(