@eltonssouza/development-utility-kit 1.0.0

package/.claude/skills/honcho-memory/tests/t006-on-prompt-submit.test.js

@@ -0,0 +1,215 @@
+/**
+ * T-006: Verify hooks/on-prompt-submit.js
+ *
+ * Tests are written BEFORE implementation (TDD RED phase).
+ * Verifies:
+ * - hook file exists
+ * - HONCHO_DRY_RUN=1 + stdin "lembra que prefiro records" → exit 0 + stdout contains "saved": true
+ * - HONCHO_DRY_RUN=1 + generic stdin → exit 0 + stdout contains peerSearchExecuted:true + sessionListExecuted:true
+ * - HONCHO_BASE_URL=http://localhost:19999 HONCHO_TIMEOUT_MS=200 → exits < 1s, exit 0, stderr contains HONCHO_WARN
+ * - HONCHO_DRY_RUN=1 + enabled=false in config → exits 0 with no-op
+ */
+
+import { existsSync } from "fs";
+import { join } from "path";
+import { spawnSync } from "child_process";
+
+const SKILL_DIR = new URL("../", import.meta.url).pathname.replace(/^\/([A-Za-z]:)/, "$1");
+const HOOK_FILE = join(SKILL_DIR, "hooks", "on-prompt-submit.js");
+const BUN_EXE = "C:\\Users\\elton\\.bun\\bin\\bun.exe";
+
+function runHook(stdin, env = {}) {
+  const result = spawnSync(
+    BUN_EXE,
+    ["run", HOOK_FILE],
+    {
+      input: stdin,
+      encoding: "utf8",
+      timeout: 5000,
+      env: { ...process.env, ...env },
+    }
+  );
+  return {
+    exitCode: result.status,
+    stdout: result.stdout ?? "",
+    stderr: result.stderr ?? "",
+    timedOut: result.error?.code === "ETIMEDOUT",
+  };
+}
+
+// Test 1: hooks/on-prompt-submit.js must exist
+const test1 = () => {
+  if (!existsSync(HOOK_FILE)) {
+    throw new Error(`hooks/on-prompt-submit.js does not exist at: ${HOOK_FILE}`);
+  }
+  console.log("PASS: hooks/on-prompt-submit.js exists");
+};
+
+// Test 2: HONCHO_DRY_RUN=1 + "lembra que prefiro records" → exit 0
+const test2 = () => {
+  const { exitCode, stdout, stderr } = runHook(
+    "lembra que prefiro records imutáveis em DTOs Java",
+    { HONCHO_DRY_RUN: "1" }
+  );
+  if (exitCode !== 0) {
+    throw new Error(`Expected exit 0, got ${exitCode}. stderr: ${stderr}`);
+  }
+  console.log("PASS: HONCHO_DRY_RUN=1 with 'lembra que' → exit 0");
+};
+
+// Test 3: HONCHO_DRY_RUN=1 + "lembra que" trigger → stdout contains "saved": true
+const test3 = () => {
+  const { exitCode, stdout, stderr } = runHook(
+    "lembra que prefiro records imutáveis em DTOs Java",
+    { HONCHO_DRY_RUN: "1" }
+  );
+  if (!stdout.includes('"saved"') && !stdout.includes('"saved":')) {
+    throw new Error(`stdout does not contain "saved". stdout: ${stdout}, stderr: ${stderr}`);
+  }
+  // Accept "saved": true or "saved":true
+  const hasSaved = stdout.includes('"saved": true') || stdout.includes('"saved":true');
+  if (!hasSaved) {
+    throw new Error(`stdout does not contain "saved": true. stdout: ${stdout}`);
+  }
+  console.log('PASS: HONCHO_DRY_RUN=1 with explicit trigger → stdout contains "saved": true');
+};
+
+// Test 4: HONCHO_DRY_RUN=1 + generic stdin → stdout contains peerSearchExecuted: true
+const test4 = () => {
+  const { exitCode, stdout, stderr } = runHook(
+    "help me refactor this controller",
+    { HONCHO_DRY_RUN: "1" }
+  );
+  if (exitCode !== 0) {
+    throw new Error(`Expected exit 0, got ${exitCode}. stderr: ${stderr}`);
+  }
+  const hasPeer = stdout.includes('"peerSearchExecuted": true') || stdout.includes('"peerSearchExecuted":true');
+  if (!hasPeer) {
+    throw new Error(`stdout does not contain peerSearchExecuted: true. stdout: ${stdout}`);
+  }
+  console.log("PASS: generic stdin → stdout contains peerSearchExecuted: true");
+};
+
+// Test 5: HONCHO_DRY_RUN=1 + generic stdin → stdout contains sessionListExecuted: true
+const test5 = () => {
+  const { exitCode, stdout, stderr } = runHook(
+    "help me refactor this controller",
+    { HONCHO_DRY_RUN: "1" }
+  );
+  if (exitCode !== 0) {
+    throw new Error(`Expected exit 0, got ${exitCode}. stderr: ${stderr}`);
+  }
+  const hasSession = stdout.includes('"sessionListExecuted": true') || stdout.includes('"sessionListExecuted":true');
+  if (!hasSession) {
+    throw new Error(`stdout does not contain sessionListExecuted: true. stdout: ${stdout}`);
+  }
+  console.log("PASS: generic stdin → stdout contains sessionListExecuted: true");
+};
+
+// Test 6: HONCHO_BASE_URL=http://localhost:19999 HONCHO_TIMEOUT_MS=200 → completes < 1s
+const test6 = () => {
+  const start = Date.now();
+  const { exitCode, stdout, stderr } = runHook(
+    "what is the current sprint?",
+    { HONCHO_BASE_URL: "http://localhost:19999", HONCHO_TIMEOUT_MS: "200" }
+  );
+  const elapsed = Date.now() - start;
+  if (elapsed >= 1000) {
+    throw new Error(`Expected completion < 1000ms, took ${elapsed}ms`);
+  }
+  if (exitCode !== 0) {
+    throw new Error(`Expected exit 0, got ${exitCode}. stderr: ${stderr}`);
+  }
+  console.log(`PASS: unreachable host completes in ${elapsed}ms < 1000ms with exit 0`);
+};
+
+// Test 7: HONCHO_BASE_URL=http://localhost:19999 HONCHO_TIMEOUT_MS=200 → stderr contains HONCHO_WARN
+const test7 = () => {
+  const { exitCode, stdout, stderr } = runHook(
+    "what is the current sprint?",
+    { HONCHO_BASE_URL: "http://localhost:19999", HONCHO_TIMEOUT_MS: "200" }
+  );
+  if (!stderr.includes("HONCHO_WARN")) {
+    throw new Error(`stderr does not contain HONCHO_WARN. stderr: ${stderr}`);
+  }
+  console.log("PASS: unreachable host → stderr contains HONCHO_WARN");
+};
+
+// Test 8: "remember that" trigger also triggers save
+const test8 = () => {
+  const { exitCode, stdout, stderr } = runHook(
+    "remember that I always use TypeScript strict mode",
+    { HONCHO_DRY_RUN: "1" }
+  );
+  if (exitCode !== 0) {
+    throw new Error(`Expected exit 0, got ${exitCode}. stderr: ${stderr}`);
+  }
+  const hasSaved = stdout.includes('"saved": true') || stdout.includes('"saved":true');
+  if (!hasSaved) {
+    throw new Error(`"remember that" trigger did not produce saved:true. stdout: ${stdout}`);
+  }
+  console.log('PASS: "remember that" trigger → saved: true');
+};
+
+// Test 9: "memoriza" trigger also triggers save
+const test9 = () => {
+  const { exitCode, stdout, stderr } = runHook(
+    "memoriza que uso sempre Conventional Commits",
+    { HONCHO_DRY_RUN: "1" }
+  );
+  if (exitCode !== 0) {
+    throw new Error(`Expected exit 0, got ${exitCode}. stderr: ${stderr}`);
+  }
+  const hasSaved = stdout.includes('"saved": true') || stdout.includes('"saved":true');
+  if (!hasSaved) {
+    throw new Error(`"memoriza" trigger did not produce saved:true. stdout: ${stdout}`);
+  }
+  console.log('PASS: "memoriza" trigger → saved: true');
+};
+
+// Test 10: "never " trigger also triggers save
+const test10 = () => {
+  const { exitCode, stdout, stderr } = runHook(
+    "never use var in TypeScript",
+    { HONCHO_DRY_RUN: "1" }
+  );
+  if (exitCode !== 0) {
+    throw new Error(`Expected exit 0, got ${exitCode}. stderr: ${stderr}`);
+  }
+  const hasSaved = stdout.includes('"saved": true') || stdout.includes('"saved":true');
+  if (!hasSaved) {
+    throw new Error(`"never " trigger did not produce saved:true. stdout: ${stdout}`);
+  }
+  console.log('PASS: "never " trigger → saved: true');
+};
+
+// Test 11: "always " trigger also triggers save
+const test11 = () => {
+  const { exitCode, stdout, stderr } = runHook(
+    "always write tests before implementation",
+    { HONCHO_DRY_RUN: "1" }
+  );
+  if (exitCode !== 0) {
+    throw new Error(`Expected exit 0, got ${exitCode}. stderr: ${stderr}`);
+  }
+  const hasSaved = stdout.includes('"saved": true') || stdout.includes('"saved":true');
+  if (!hasSaved) {
+    throw new Error(`"always " trigger did not produce saved:true. stdout: ${stdout}`);
+  }
+  console.log('PASS: "always " trigger → saved: true');
+};
+
+// Run all tests
+let failed = 0;
+const tests = [test1, test2, test3, test4, test5, test6, test7, test8, test9, test10, test11];
+for (const t of tests) {
+  try {
+    await t();
+  } catch (e) {
+    console.error(`FAIL: ${e.message}`);
+    failed++;
+  }
+}
+
+console.log(`\nT-006 Results: ${tests.length - failed}/${tests.length} passed`);
+process.exit(failed > 0 ? 1 : 0);

package/.claude/skills/honcho-memory/tests/t007-on-stop.test.js

@@ -0,0 +1,165 @@
+/**
+ * T-007: Verify hooks/on-stop.js
+ *
+ * Tests are written BEFORE implementation (TDD RED phase).
+ * Verifies:
+ * - hook file exists
+ * - HONCHO_DRY_RUN=1 → exit 0 + stdout contains "type": "project-context"
+ * - HONCHO_INFERENCE_ENABLED=true HONCHO_DRY_RUN=1 → stderr contains "HONCHO_INFO: inference deferred"
+ * - hook completes quickly (< 2s in dry-run mode)
+ * - exit code is always 0 (never blocks)
+ */
+
+import { existsSync } from "fs";
+import { join } from "path";
+import { spawnSync } from "child_process";
+
+const SKILL_DIR = new URL("../", import.meta.url).pathname.replace(/^\/([A-Za-z]:)/, "$1");
+const HOOK_FILE = join(SKILL_DIR, "hooks", "on-stop.js");
+const BUN_EXE = "C:\\Users\\elton\\.bun\\bin\\bun.exe";
+
+function runHook(env = {}) {
+  const result = spawnSync(
+    BUN_EXE,
+    ["run", HOOK_FILE],
+    {
+      encoding: "utf8",
+      timeout: 10000,
+      env: { ...process.env, ...env },
+    }
+  );
+  return {
+    exitCode: result.status,
+    stdout: result.stdout ?? "",
+    stderr: result.stderr ?? "",
+    timedOut: result.error?.code === "ETIMEDOUT",
+  };
+}
+
+// Test 1: hooks/on-stop.js must exist
+const test1 = () => {
+  if (!existsSync(HOOK_FILE)) {
+    throw new Error(`hooks/on-stop.js does not exist at: ${HOOK_FILE}`);
+  }
+  console.log("PASS: hooks/on-stop.js exists");
+};
+
+// Test 2: HONCHO_DRY_RUN=1 → exit 0
+const test2 = () => {
+  const { exitCode, stderr } = runHook({ HONCHO_DRY_RUN: "1" });
+  if (exitCode !== 0) {
+    throw new Error(`Expected exit 0, got ${exitCode}. stderr: ${stderr}`);
+  }
+  console.log("PASS: HONCHO_DRY_RUN=1 → exit 0");
+};
+
+// Test 3: HONCHO_DRY_RUN=1 → stdout contains "type": "project-context"
+const test3 = () => {
+  const { exitCode, stdout, stderr } = runHook({ HONCHO_DRY_RUN: "1" });
+  const hasType =
+    stdout.includes('"type": "project-context"') ||
+    stdout.includes('"type":"project-context"');
+  if (!hasType) {
+    throw new Error(`stdout does not contain "type": "project-context". stdout: ${stdout}, stderr: ${stderr}`);
+  }
+  console.log('PASS: HONCHO_DRY_RUN=1 → stdout contains "type": "project-context"');
+};
+
+// Test 4: HONCHO_INFERENCE_ENABLED=true HONCHO_DRY_RUN=1 → stderr contains "HONCHO_INFO: inference deferred"
+const test4 = () => {
+  const { exitCode, stdout, stderr } = runHook({
+    HONCHO_DRY_RUN: "1",
+    HONCHO_INFERENCE_ENABLED: "true",
+  });
+  if (!stderr.includes("HONCHO_INFO: inference deferred")) {
+    throw new Error(`stderr does not contain "HONCHO_INFO: inference deferred". stderr: ${stderr}`);
+  }
+  console.log("PASS: HONCHO_INFERENCE_ENABLED=true → stderr contains HONCHO_INFO: inference deferred");
+};
+
+// Test 5: HONCHO_INFERENCE_ENABLED=true HONCHO_DRY_RUN=1 → still exits 0
+const test5 = () => {
+  const { exitCode, stderr } = runHook({
+    HONCHO_DRY_RUN: "1",
+    HONCHO_INFERENCE_ENABLED: "true",
+  });
+  if (exitCode !== 0) {
+    throw new Error(`Expected exit 0 with inference enabled, got ${exitCode}. stderr: ${stderr}`);
+  }
+  console.log("PASS: HONCHO_INFERENCE_ENABLED=true still exits 0");
+};
+
+// Test 6: dry-run completes in < 2s
+const test6 = () => {
+  const start = Date.now();
+  const { exitCode, stderr } = runHook({ HONCHO_DRY_RUN: "1" });
+  const elapsed = Date.now() - start;
+  if (elapsed >= 2000) {
+    throw new Error(`Expected completion < 2000ms in dry-run, took ${elapsed}ms`);
+  }
+  console.log(`PASS: dry-run completes in ${elapsed}ms < 2000ms`);
+};
+
+// Test 7: stdout is valid JSON in dry-run
+const test7 = () => {
+  const { stdout, stderr } = runHook({ HONCHO_DRY_RUN: "1" });
+  // Find JSON content in stdout (may be one JSON line among others)
+  const lines = stdout.trim().split("\n").filter((l) => l.trim().startsWith("{"));
+  if (lines.length === 0) {
+    throw new Error(`No JSON line found in stdout. stdout: ${stdout}`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(lines[0]);
+  } catch (e) {
+    throw new Error(`stdout JSON is not valid: ${lines[0]}. Error: ${e.message}`);
+  }
+  if (!parsed.type) {
+    throw new Error(`Parsed JSON missing 'type' field. got: ${JSON.stringify(parsed)}`);
+  }
+  console.log(`PASS: stdout contains valid JSON with type field: ${parsed.type}`);
+};
+
+// Test 8: unreachable host + no dry-run → still exits 0 (non-blocking)
+const test8 = () => {
+  const { exitCode, stderr } = runHook({
+    HONCHO_BASE_URL: "http://localhost:19999",
+    HONCHO_TIMEOUT_MS: "200",
+  });
+  if (exitCode !== 0) {
+    throw new Error(`Expected exit 0 on unreachable host, got ${exitCode}. stderr: ${stderr}`);
+  }
+  console.log("PASS: unreachable host → still exits 0 (non-blocking)");
+};
+
+// Test 9: HONCHO_INFERENCE_ENABLED=true stdout still contains "project-context"
+const test9 = () => {
+  const { stdout, stderr } = runHook({
+    HONCHO_DRY_RUN: "1",
+    HONCHO_INFERENCE_ENABLED: "true",
+  });
+  const hasType =
+    stdout.includes('"type": "project-context"') ||
+    stdout.includes('"type":"project-context"');
+  if (!hasType) {
+    throw new Error(
+      `With inferenceEnabled, stdout still must contain project-context. stdout: ${stdout}`
+    );
+  }
+  console.log("PASS: HONCHO_INFERENCE_ENABLED=true → stdout still contains project-context");
+};
+
+// Run all tests
+let failed = 0;
+const tests = [test1, test2, test3, test4, test5, test6, test7, test8, test9];
+for (const t of tests) {
+  try {
+    await t();
+  } catch (e) {
+    console.error(`FAIL: ${e.message}`);
+    failed++;
+  }
+}
+
+console.log(`\nT-007 Results: ${tests.length - failed}/${tests.length} passed`);
+process.exit(failed > 0 ? 1 : 0);

package/.claude/skills/honcho-memory/tests/t008-cli.test.js

@@ -0,0 +1,214 @@
+/**
+ * T-008: Verify scripts/cli.js — subcommands save, search, list, forget, status
+ *
+ * Tests written BEFORE implementation (TDD RED phase).
+ *
+ * DoD assertions:
+ * - With HONCHO_DRY_RUN=1:
+ *   - `status`        → exit 0, stdout contains "connection:", "memories:", "enabled:", "inferenceEnabled:"
+ *   - `save "test"`   → exit 0
+ *   - `list`          → exit 0
+ *   - `search "test"` → exit 0
+ *   - `forget someId` → exit 0, stdout contains "method": "PUT"
+ *   - `forget` (no ID)→ exit 1
+ */
+
+import { existsSync } from "fs";
+import { join } from "path";
+import { spawnSync } from "child_process";
+
+const SKILL_DIR = new URL("../", import.meta.url).pathname.replace(/^\/([A-Za-z]:)/, "$1");
+const CLI_FILE = join(SKILL_DIR, "scripts", "cli.js");
+const BUN_EXE = "C:\\Users\\elton\\.bun\\bin\\bun.exe";
+
+function runCli(args, env = {}) {
+  const result = spawnSync(
+    BUN_EXE,
+    ["run", CLI_FILE, ...args],
+    {
+      encoding: "utf8",
+      timeout: 10000,
+      env: { ...process.env, HONCHO_DRY_RUN: "1", ...env },
+    }
+  );
+  return {
+    exitCode: result.status,
+    stdout: result.stdout ?? "",
+    stderr: result.stderr ?? "",
+    timedOut: result.error?.code === "ETIMEDOUT",
+  };
+}
+
+// Test 1: scripts/cli.js must exist
+const test1 = () => {
+  if (!existsSync(CLI_FILE)) {
+    throw new Error(`scripts/cli.js does not exist at: ${CLI_FILE}`);
+  }
+  console.log("PASS: scripts/cli.js exists");
+};
+
+// Test 2: `status` → exit 0
+const test2 = () => {
+  const { exitCode, stdout, stderr } = runCli(["status"]);
+  if (exitCode !== 0) {
+    throw new Error(`status: expected exit 0, got ${exitCode}. stderr: ${stderr}`);
+  }
+  console.log("PASS: `status` → exit 0");
+};
+
+// Test 3: `status` stdout contains "connection:"
+const test3 = () => {
+  const { exitCode, stdout, stderr } = runCli(["status"]);
+  if (!stdout.includes("connection:")) {
+    throw new Error(`status: stdout missing "connection:". stdout: ${stdout}`);
+  }
+  console.log("PASS: `status` stdout contains \"connection:\"");
+};
+
+// Test 4: `status` stdout contains "memories:"
+const test4 = () => {
+  const { stdout } = runCli(["status"]);
+  if (!stdout.includes("memories:")) {
+    throw new Error(`status: stdout missing "memories:". stdout: ${stdout}`);
+  }
+  console.log("PASS: `status` stdout contains \"memories:\"");
+};
+
+// Test 5: `status` stdout contains "enabled:"
+const test5 = () => {
+  const { stdout } = runCli(["status"]);
+  if (!stdout.includes("enabled:")) {
+    throw new Error(`status: stdout missing "enabled:". stdout: ${stdout}`);
+  }
+  console.log("PASS: `status` stdout contains \"enabled:\"");
+};
+
+// Test 6: `status` stdout contains "inferenceEnabled:"
+const test6 = () => {
+  const { stdout } = runCli(["status"]);
+  if (!stdout.includes("inferenceEnabled:")) {
+    throw new Error(`status: stdout missing "inferenceEnabled:". stdout: ${stdout}`);
+  }
+  console.log("PASS: `status` stdout contains \"inferenceEnabled:\"");
+};
+
+// Test 7: `save "test"` → exit 0
+const test7 = () => {
+  const { exitCode, stderr } = runCli(["save", "test"]);
+  if (exitCode !== 0) {
+    throw new Error(`save: expected exit 0, got ${exitCode}. stderr: ${stderr}`);
+  }
+  console.log("PASS: `save \"test\"` → exit 0");
+};
+
+// Test 8: `list` → exit 0
+const test8 = () => {
+  const { exitCode, stderr } = runCli(["list"]);
+  if (exitCode !== 0) {
+    throw new Error(`list: expected exit 0, got ${exitCode}. stderr: ${stderr}`);
+  }
+  console.log("PASS: `list` → exit 0");
+};
+
+// Test 9: `search "test"` → exit 0
+const test9 = () => {
+  const { exitCode, stderr } = runCli(["search", "test"]);
+  if (exitCode !== 0) {
+    throw new Error(`search: expected exit 0, got ${exitCode}. stderr: ${stderr}`);
+  }
+  console.log("PASS: `search \"test\"` → exit 0");
+};
+
+// Test 10: `forget someId` → exit 0
+const test10 = () => {
+  const { exitCode, stderr } = runCli(["forget", "someId"]);
+  if (exitCode !== 0) {
+    throw new Error(`forget someId: expected exit 0, got ${exitCode}. stderr: ${stderr}`);
+  }
+  console.log("PASS: `forget someId` → exit 0");
+};
+
+// Test 11: `forget someId` stdout contains "method": "PUT"
+const test11 = () => {
+  const { stdout, stderr } = runCli(["forget", "someId"]);
+  const hasPut =
+    stdout.includes('"method": "PUT"') ||
+    stdout.includes('"method":"PUT"');
+  if (!hasPut) {
+    throw new Error(`forget someId: stdout missing "method": "PUT". stdout: ${stdout}`);
+  }
+  console.log("PASS: `forget someId` stdout contains \"method\": \"PUT\"");
+};
+
+// Test 12: `forget` (no ID) → exit 1
+const test12 = () => {
+  const { exitCode, stdout, stderr } = runCli(["forget"]);
+  if (exitCode !== 1) {
+    throw new Error(`forget (no ID): expected exit 1, got ${exitCode}. stdout: ${stdout}, stderr: ${stderr}`);
+  }
+  console.log("PASS: `forget` (no ID) → exit 1");
+};
+
+// Test 13: `forget` (no ID) outputs an error message
+const test13 = () => {
+  const { exitCode, stdout, stderr } = runCli(["forget"]);
+  const combinedOutput = stdout + stderr;
+  if (!combinedOutput.includes("error") && !combinedOutput.includes("Error") &&
+      !combinedOutput.includes("required") && !combinedOutput.includes("missing") &&
+      !combinedOutput.includes("Usage") && !combinedOutput.includes("ID")) {
+    throw new Error(`forget (no ID): expected an error/usage message. stdout: ${stdout}, stderr: ${stderr}`);
+  }
+  console.log("PASS: `forget` (no ID) outputs an error/usage message");
+};
+
+// Test 14: unknown subcommand → non-zero exit or helpful message
+const test14 = () => {
+  const { exitCode, stdout, stderr } = runCli(["unknown-subcommand"]);
+  // Should not succeed silently
+  const combinedOutput = stdout + stderr;
+  if (exitCode === 0 && combinedOutput.trim() === "") {
+    throw new Error("unknown subcommand: expected non-zero exit or output. Got silent exit 0");
+  }
+  console.log(`PASS: unknown subcommand → handled (exit ${exitCode})`);
+};
+
+// Test 15: `status` completes in < 3s (dry-run should be fast)
+const test15 = () => {
+  const start = Date.now();
+  runCli(["status"]);
+  const elapsed = Date.now() - start;
+  if (elapsed >= 3000) {
+    throw new Error(`status: expected completion < 3000ms, took ${elapsed}ms`);
+  }
+  console.log(`PASS: status completes in ${elapsed}ms < 3000ms`);
+};
+
+// Test 16: `save` without text argument → handles gracefully (exit 0 or 1, but no crash)
+const test16 = () => {
+  const { exitCode, timedOut } = runCli(["save"]);
+  if (timedOut) {
+    throw new Error("save (no text): command timed out");
+  }
+  // Accept either exit code — important it does not hang
+  console.log(`PASS: save (no text) completes without hanging (exit ${exitCode})`);
+};
+
+// Run all tests
+let failed = 0;
+const tests = [
+  test1, test2, test3, test4, test5, test6,
+  test7, test8, test9, test10, test11, test12,
+  test13, test14, test15, test16,
+];
+
+for (const t of tests) {
+  try {
+    await t();
+  } catch (e) {
+    console.error(`FAIL: ${e.message}`);
+    failed++;
+  }
+}
+
+console.log(`\nT-008 Results: ${tests.length - failed}/${tests.length} passed`);
+process.exit(failed > 0 ? 1 : 0);