@eltonssouza/development-utility-kit 1.0.0

package/.claude/skills/honcho-memory/tests/t009-setup.test.js

@@ -0,0 +1,232 @@
+/**
+ * T-009: Verify scripts/setup.js — wizard + migration of memory/*.md
+ *
+ * Tests written BEFORE implementation (TDD RED phase).
+ *
+ * DoD assertions:
+ * - `bun run scripts/setup.js --dry-run` → exit 0, stdout contains "DRY_RUN:"
+ * - When no memory/*.md files exist → stdout contains "DRY_RUN: no memory files found"
+ * - When memory/*.md files exist → stdout contains "DRY_RUN: would migrate N files"
+ * - Two consecutive --dry-run calls both return exit 0 (idempotence)
+ * - Config missing → still exits 0 (graceful degradation), stdout contains "DRY_RUN:"
+ */
+
+import { existsSync, mkdirSync, writeFileSync, rmSync } from "fs";
+import { join } from "path";
+import { spawnSync } from "child_process";
+import { tmpdir } from "os";
+
+const SKILL_DIR = new URL("../", import.meta.url).pathname.replace(/^\/([A-Za-z]:)/, "$1");
+const SETUP_FILE = join(SKILL_DIR, "scripts", "setup.js");
+const BUN_EXE = "C:\\Users\\elton\\.bun\\bin\\bun.exe";
+
+function runSetup(args, cwd, env = {}) {
+  const result = spawnSync(
+    BUN_EXE,
+    ["run", SETUP_FILE, ...args],
+    {
+      encoding: "utf8",
+      timeout: 15000,
+      cwd: cwd ?? process.cwd(),
+      env: { ...process.env, ...env },
+    }
+  );
+  return {
+    exitCode: result.status,
+    stdout: result.stdout ?? "",
+    stderr: result.stderr ?? "",
+    timedOut: result.error?.code === "ETIMEDOUT",
+  };
+}
+
+/** Create a temp directory with optional memory/*.md files */
+function makeTempDir(withMemoryFiles = false) {
+  const dir = join(tmpdir(), `honcho-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+  mkdirSync(dir, { recursive: true });
+  if (withMemoryFiles) {
+    mkdirSync(join(dir, "memory"), { recursive: true });
+    writeFileSync(join(dir, "memory", "test1.md"), "# Memory 1\nThis is a test memory.");
+    writeFileSync(join(dir, "memory", "test2.md"), "# Memory 2\nAnother test memory.");
+  }
+  return dir;
+}
+
+// Test 1: scripts/setup.js must exist
+const test1 = () => {
+  if (!existsSync(SETUP_FILE)) {
+    throw new Error(`scripts/setup.js does not exist at: ${SETUP_FILE}`);
+  }
+  console.log("PASS: scripts/setup.js exists");
+};
+
+// Test 2: --dry-run → exit 0
+const test2 = () => {
+  const dir = makeTempDir(false);
+  try {
+    const { exitCode, stderr } = runSetup(["--dry-run"], dir);
+    if (exitCode !== 0) {
+      throw new Error(`--dry-run: expected exit 0, got ${exitCode}. stderr: ${stderr}`);
+    }
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+  console.log("PASS: --dry-run → exit 0");
+};
+
+// Test 3: --dry-run stdout contains "DRY_RUN:"
+const test3 = () => {
+  const dir = makeTempDir(false);
+  try {
+    const { stdout, stderr } = runSetup(["--dry-run"], dir);
+    if (!stdout.includes("DRY_RUN:")) {
+      throw new Error(`--dry-run: stdout missing "DRY_RUN:". stdout: ${stdout}, stderr: ${stderr}`);
+    }
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+  console.log("PASS: --dry-run stdout contains \"DRY_RUN:\"");
+};
+
+// Test 4: --dry-run with NO memory files → stdout contains "no memory files found"
+const test4 = () => {
+  const dir = makeTempDir(false); // no memory/ dir
+  try {
+    const { stdout } = runSetup(["--dry-run"], dir);
+    if (!stdout.includes("no memory files found")) {
+      throw new Error(`--dry-run no files: stdout missing "no memory files found". stdout: ${stdout}`);
+    }
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+  console.log("PASS: --dry-run (no files) stdout contains \"no memory files found\"");
+};
+
+// Test 5: --dry-run with memory files → stdout contains "would migrate N files"
+const test5 = () => {
+  const dir = makeTempDir(true); // creates 2 .md files
+  try {
+    const { stdout } = runSetup(["--dry-run"], dir);
+    if (!stdout.includes("would migrate")) {
+      throw new Error(`--dry-run with files: stdout missing "would migrate". stdout: ${stdout}`);
+    }
+    if (!stdout.includes("2 files") && !stdout.includes("2")) {
+      throw new Error(`--dry-run with files: stdout should mention count 2. stdout: ${stdout}`);
+    }
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+  console.log("PASS: --dry-run (with 2 files) stdout contains \"would migrate 2 files\"");
+};
+
+// Test 6: --dry-run is idempotent — two calls both exit 0
+const test6 = () => {
+  const dir = makeTempDir(false);
+  try {
+    const { exitCode: exit1 } = runSetup(["--dry-run"], dir);
+    const { exitCode: exit2 } = runSetup(["--dry-run"], dir);
+    if (exit1 !== 0) {
+      throw new Error(`idempotence: first call exit ${exit1}, expected 0`);
+    }
+    if (exit2 !== 0) {
+      throw new Error(`idempotence: second call exit ${exit2}, expected 0`);
+    }
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+  console.log("PASS: two consecutive --dry-run calls both exit 0 (idempotent)");
+};
+
+// Test 7: --dry-run is idempotent with memory files
+const test7 = () => {
+  const dir = makeTempDir(true);
+  try {
+    const { exitCode: exit1, stdout: out1 } = runSetup(["--dry-run"], dir);
+    const { exitCode: exit2, stdout: out2 } = runSetup(["--dry-run"], dir);
+    if (exit1 !== 0) {
+      throw new Error(`idempotence with files: first call exit ${exit1}, expected 0`);
+    }
+    if (exit2 !== 0) {
+      throw new Error(`idempotence with files: second call exit ${exit2}, expected 0. stdout: ${out2}`);
+    }
+    if (!out1.includes("DRY_RUN:") || !out2.includes("DRY_RUN:")) {
+      throw new Error(`idempotence: both calls must contain "DRY_RUN:". out1: ${out1}, out2: ${out2}`);
+    }
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+  console.log("PASS: two consecutive --dry-run (with files) calls both exit 0 and contain DRY_RUN:");
+};
+
+// Test 8: missing config → still exits 0 with graceful degradation
+const test8 = () => {
+  const dir = makeTempDir(false);
+  try {
+    // Override config path to something that does not exist
+    const { exitCode, stdout, stderr } = runSetup(
+      ["--dry-run"],
+      dir,
+      { HONCHO_CONFIG_PATH: join(dir, "nonexistent-config.json") }
+    );
+    if (exitCode !== 0) {
+      throw new Error(`missing config: expected exit 0, got ${exitCode}. stderr: ${stderr}`);
+    }
+    // Must still output DRY_RUN: line
+    if (!stdout.includes("DRY_RUN:")) {
+      throw new Error(`missing config: stdout missing "DRY_RUN:". stdout: ${stdout}`);
+    }
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+  console.log("PASS: missing config → exit 0 with graceful degradation, DRY_RUN: in stdout");
+};
+
+// Test 9: --dry-run completes in < 5s (connection attempt should timeout fast)
+const test9 = () => {
+  const dir = makeTempDir(false);
+  try {
+    const start = Date.now();
+    const { exitCode, timedOut } = runSetup(["--dry-run"], dir);
+    const elapsed = Date.now() - start;
+    if (timedOut) {
+      throw new Error("--dry-run timed out at 15s");
+    }
+    if (elapsed >= 5000) {
+      throw new Error(`--dry-run took ${elapsed}ms, expected < 5000ms`);
+    }
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+  console.log("PASS: --dry-run completes in < 5s");
+};
+
+// Test 10: --dry-run with 1 .md file → mentions 1 file
+const test10 = () => {
+  const dir = makeTempDir(false);
+  try {
+    mkdirSync(join(dir, "memory"), { recursive: true });
+    writeFileSync(join(dir, "memory", "single.md"), "# Single memory\nContent here.");
+    const { stdout } = runSetup(["--dry-run"], dir);
+    if (!stdout.includes("would migrate") || !stdout.includes("1")) {
+      throw new Error(`1-file case: stdout should mention 1 file. stdout: ${stdout}`);
+    }
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+  console.log("PASS: --dry-run with 1 file → stdout mentions 1 file");
+};
+
+// Run all tests
+let failed = 0;
+const tests = [test1, test2, test3, test4, test5, test6, test7, test8, test9, test10];
+
+for (const t of tests) {
+  try {
+    await t();
+  } catch (e) {
+    console.error(`FAIL: ${e.message}`);
+    failed++;
+  }
+}
+
+console.log(`\nT-009 Results: ${tests.length - failed}/${tests.length} passed`);
+process.exit(failed > 0 ? 1 : 0);

package/.claude/skills/honcho-memory/tests/t010-skill-md.test.js

@@ -0,0 +1,114 @@
+/**
+ * T-010 — Tests for .claude/skills/honcho-memory/SKILL.md
+ * DoD:
+ *   - file exists
+ *   - contains `name: honcho-memory` in frontmatter
+ *   - body contains `[HONCHO MEMORY]`
+ *   - body contains `graceful`
+ *   - body contains note about forget using soft-delete via PUT
+ */
+
+import { readFileSync, existsSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const SKILL_MD_PATH = join(__dirname, '..', 'SKILL.md');
+
+// --- helpers ---
+function readSkillMd() {
+  if (!existsSync(SKILL_MD_PATH)) {
+    return null;
+  }
+  return readFileSync(SKILL_MD_PATH, 'utf8');
+}
+
+function parseFrontmatter(content) {
+  const match = content.match(/^---\s*\n([\s\S]*?)\n---/);
+  if (!match) return null;
+  return match[1];
+}
+
+// --- tests ---
+let passed = 0;
+let failed = 0;
+
+function assert(condition, label) {
+  if (condition) {
+    console.log(`  PASS: ${label}`);
+    passed++;
+  } else {
+    console.error(`  FAIL: ${label}`);
+    failed++;
+  }
+}
+
+console.log('\n=== T-010: SKILL.md ===\n');
+
+const content = readSkillMd();
+
+assert(content !== null, 'SKILL.md exists');
+
+if (content !== null) {
+  const frontmatter = parseFrontmatter(content);
+  assert(frontmatter !== null, 'Has YAML frontmatter delimited by ---');
+  assert(
+    frontmatter !== null && frontmatter.includes('name: honcho-memory'),
+    'Frontmatter contains name: honcho-memory'
+  );
+
+  assert(
+    content.includes('[HONCHO MEMORY]'),
+    'Body contains [HONCHO MEMORY] block marker'
+  );
+
+  assert(
+    content.includes('graceful'),
+    'Body contains "graceful" (degradation graceful)'
+  );
+
+  assert(
+    content.includes('PUT') && content.toLowerCase().includes('soft-delete') ||
+    content.includes('PUT') && content.includes('soft delete'),
+    'Body contains soft-delete via PUT note for forget command'
+  );
+
+  // trigger coverage
+  const triggers = [
+    'honcho memory',
+    'memória honcho',
+    'lembra que',
+    'remember that',
+    'memoriza',
+    '/honcho save',
+    '/honcho search',
+    '/honcho list',
+    '/honcho forget',
+    '/honcho status',
+    '/honcho setup',
+  ];
+  for (const trigger of triggers) {
+    const found = content.toLowerCase().includes(trigger.toLowerCase());
+    assert(found, `Contains trigger: "${trigger}"`);
+  }
+
+  // subcommands documented
+  const subcmds = ['save', 'search', 'list', 'forget', 'status', 'setup'];
+  for (const cmd of subcmds) {
+    assert(content.includes(cmd), `Documents subcommand: ${cmd}`);
+  }
+
+  assert(
+    content.includes('config.json'),
+    'References config.json location'
+  );
+
+  assert(
+    content.includes('setup.js') || content.includes('setup'),
+    'References setup script'
+  );
+}
+
+console.log(`\nResults: ${passed} passed, ${failed} failed`);
+process.exit(failed > 0 ? 1 : 0);

package/.claude/skills/honcho-memory/tests/t011-settings-hooks.test.js

@@ -0,0 +1,105 @@
+/**
+ * T-011 — Tests for hooks registration in C:/Users/elton/.claude/settings.json
+ * DoD:
+ *   - settings.json is valid JSON (exit 0 on parse)
+ *   - hooks.UserPromptSubmit is present and contains on-prompt-submit.js command
+ *   - hooks.Stop is present and contains on-stop.js command
+ *   - commands use forward slashes (IR-006)
+ *   - commands point to the harness path (Option B — C:/development/tools/development-utility-kit/...)
+ *   - rest of the file is preserved (permissions key still exists)
+ */
+
+import { readFileSync, existsSync } from 'fs';
+
+const SETTINGS_PATH = 'C:/Users/elton/.claude/settings.json';
+
+let passed = 0;
+let failed = 0;
+
+function assert(condition, label) {
+  if (condition) {
+    console.log(`  PASS: ${label}`);
+    passed++;
+  } else {
+    console.error(`  FAIL: ${label}`);
+    failed++;
+  }
+}
+
+console.log('\n=== T-011: settings.json hooks registration ===\n');
+
+assert(existsSync(SETTINGS_PATH), 'settings.json exists');
+
+let settings = null;
+try {
+  settings = JSON.parse(readFileSync(SETTINGS_PATH, 'utf8'));
+  assert(true, 'settings.json is valid JSON');
+} catch (e) {
+  assert(false, `settings.json is valid JSON (error: ${e.message})`);
+}
+
+if (settings) {
+  // Existing content preserved
+  assert(
+    settings.permissions !== undefined,
+    'permissions key preserved (existing content intact)'
+  );
+
+  // hooks key exists
+  assert(settings.hooks !== undefined, 'hooks key exists in settings.json');
+
+  if (settings.hooks) {
+    // UserPromptSubmit
+    const ups = settings.hooks.UserPromptSubmit;
+    assert(Array.isArray(ups) && ups.length > 0, 'hooks.UserPromptSubmit is a non-empty array');
+
+    if (Array.isArray(ups) && ups.length > 0) {
+      const allCommands = ups.flatMap(entry =>
+        (entry.hooks || []).map(h => h.command || '')
+      );
+      const hasPromptHook = allCommands.some(cmd => cmd.includes('on-prompt-submit.js'));
+      assert(hasPromptHook, 'UserPromptSubmit contains on-prompt-submit.js command');
+
+      const usesHarnessPath = allCommands.some(cmd =>
+        cmd.includes('C:/development/tools/development-utility-kit') ||
+        cmd.includes('development-utility-kit')
+      );
+      assert(usesHarnessPath, 'UserPromptSubmit command uses harness path (Option B)');
+
+      const usesForwardSlashes = allCommands.some(cmd =>
+        cmd.includes('on-prompt-submit.js') && !cmd.includes('\\')
+      );
+      assert(usesForwardSlashes, 'UserPromptSubmit command uses forward slashes (IR-006)');
+
+      // Check matcher exists
+      const hasMatcher = ups.some(entry => entry.matcher !== undefined);
+      assert(hasMatcher, 'UserPromptSubmit entry has matcher field');
+    }
+
+    // Stop
+    const stop = settings.hooks.Stop;
+    assert(Array.isArray(stop) && stop.length > 0, 'hooks.Stop is a non-empty array');
+
+    if (Array.isArray(stop) && stop.length > 0) {
+      const allCmds = stop.flatMap(entry =>
+        (entry.hooks || []).map(h => h.command || '')
+      );
+      const hasStopHook = allCmds.some(cmd => cmd.includes('on-stop.js'));
+      assert(hasStopHook, 'Stop contains on-stop.js command');
+
+      const usesHarnessPathStop = allCmds.some(cmd =>
+        cmd.includes('C:/development/tools/development-utility-kit') ||
+        cmd.includes('development-utility-kit')
+      );
+      assert(usesHarnessPathStop, 'Stop command uses harness path (Option B)');
+
+      const usesForwardSlashesStop = allCmds.some(cmd =>
+        cmd.includes('on-stop.js') && !cmd.includes('\\')
+      );
+      assert(usesForwardSlashesStop, 'Stop command uses forward slashes (IR-006)');
+    }
+  }
+}
+
+console.log(`\nResults: ${passed} passed, ${failed} failed`);
+process.exit(failed > 0 ? 1 : 0);

package/.claude/skills/honcho-memory/tests/t012-docs-update.test.js

@@ -0,0 +1,106 @@
+/**
+ * T-012 — Tests for CLAUDE.md and .claude/skills/README.md updates
+ * DoD:
+ *   - CLAUDE.md contains "honcho-memory"
+ *   - .claude/skills/README.md contains "honcho-memory"
+ *   - Both files reference honcho-memory skill entry with triggers and output description
+ */
+
+import { readFileSync, existsSync } from 'fs';
+import { join } from 'path';
+
+const HARNESS_ROOT = 'C:/development/tools/development-utility-kit';
+const CLAUDE_MD_PATH = join(HARNESS_ROOT, 'CLAUDE.md');
+const README_PATH = join(HARNESS_ROOT, '.claude/skills/README.md');
+
+let passed = 0;
+let failed = 0;
+
+function assert(condition, label) {
+  if (condition) {
+    console.log(`  PASS: ${label}`);
+    passed++;
+  } else {
+    console.error(`  FAIL: ${label}`);
+    failed++;
+  }
+}
+
+console.log('\n=== T-012: CLAUDE.md + README.md documentation update ===\n');
+
+// --- CLAUDE.md checks ---
+assert(existsSync(CLAUDE_MD_PATH), 'CLAUDE.md exists');
+
+let claudeMd = null;
+try {
+  claudeMd = readFileSync(CLAUDE_MD_PATH, 'utf8');
+  assert(true, 'CLAUDE.md is readable');
+} catch (e) {
+  assert(false, `CLAUDE.md is readable (error: ${e.message})`);
+}
+
+if (claudeMd) {
+  assert(
+    claudeMd.includes('honcho-memory'),
+    'CLAUDE.md contains honcho-memory'
+  );
+
+  // Should have it in the skills table
+  const linesWithHoncho = claudeMd.split('\n').filter(l => l.includes('honcho-memory'));
+  assert(
+    linesWithHoncho.length > 0,
+    'CLAUDE.md skills table row contains honcho-memory'
+  );
+
+  // The row should mention triggers
+  const tableRow = linesWithHoncho.find(l => l.includes('|'));
+  assert(
+    tableRow !== undefined,
+    'honcho-memory appears in a table row (pipe-delimited)'
+  );
+
+  // The row should reference some trigger
+  const hasTrigger = linesWithHoncho.some(l =>
+    l.includes('lembra que') ||
+    l.includes('/honcho') ||
+    l.includes('remember that') ||
+    l.includes('honcho')
+  );
+  assert(hasTrigger, 'honcho-memory row references triggers');
+}
+
+// --- README.md checks ---
+assert(existsSync(README_PATH), '.claude/skills/README.md exists');
+
+let readmeMd = null;
+try {
+  readmeMd = readFileSync(README_PATH, 'utf8');
+  assert(true, '.claude/skills/README.md is readable');
+} catch (e) {
+  assert(false, `.claude/skills/README.md is readable (error: ${e.message})`);
+}
+
+if (readmeMd) {
+  assert(
+    readmeMd.includes('honcho-memory'),
+    '.claude/skills/README.md contains honcho-memory'
+  );
+
+  // Should have a link to SKILL.md
+  assert(
+    readmeMd.includes('honcho-memory/SKILL.md') ||
+    readmeMd.includes('honcho-memory'),
+    'README.md references honcho-memory skill entry'
+  );
+
+  // Table row with pipe
+  const linesWithHoncho = readmeMd.split('\n').filter(l => l.includes('honcho-memory'));
+  const tableRow = linesWithHoncho.find(l => l.includes('|'));
+  assert(
+    tableRow !== undefined,
+    'honcho-memory appears in README.md table row'
+  );
+}
+
+console.log(`\nResults: ${passed} passed, ${failed} failed`);
+process.exit(failed > 0 ? 1 : 0);

package/.claude/skills/honcho-memory/tests/t013-smoke-e2e.test.js

@@ -0,0 +1,90 @@
+/**
+ * T-013 — Smoke test E2E
+ * DoD:
+ *   1. `bun run scripts/cli.js status` → exit 0, stdout contains `connection: OK` or `connection: FAIL`
+ *   2. `bun run scripts/cli.js forget testId` → exit 0, stdout does NOT contain `DELETE` (confirms soft-delete via PUT)
+ *   3. `HONCHO_DRY_RUN=1 bun run hooks/on-prompt-submit.js` with generic stdin → exit 0
+ */
+
+import { spawnSync } from 'child_process';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const SKILL_ROOT = join(__dirname, '..');
+const BUN = 'C:/Users/elton/.bun/bin/bun.exe';
+
+let passed = 0;
+let failed = 0;
+
+function assert(condition, label) {
+  if (condition) {
+    console.log(`  PASS: ${label}`);
+    passed++;
+  } else {
+    console.error(`  FAIL: ${label}`);
+    failed++;
+  }
+}
+
+function runBun(args, env = {}, input = null) {
+  const result = spawnSync(BUN, ['run', ...args], {
+    cwd: SKILL_ROOT,
+    env: { ...process.env, ...env },
+    input: input ? input : undefined,
+    encoding: 'utf8',
+    timeout: 15000,
+  });
+  return {
+    exitCode: result.status ?? 1,
+    stdout: result.stdout ?? '',
+    stderr: result.stderr ?? '',
+  };
+}
+
+console.log('\n=== T-013: Smoke test E2E ===\n');
+
+// --- Check 1: cli.js status ---
+console.log('Check 1: cli.js status');
+{
+  const r = runBun(['scripts/cli.js', 'status'], { HONCHO_DRY_RUN: '1' });
+  assert(r.exitCode === 0, 'cli.js status exits 0');
+  const combined = r.stdout + r.stderr;
+  const hasConnectionStatus =
+    combined.includes('connection: OK') ||
+    combined.includes('connection: FAIL') ||
+    combined.includes('connection:');
+  assert(hasConnectionStatus, 'cli.js status stdout/stderr contains "connection:"');
+}
+
+// --- Check 2: cli.js forget testId — soft-delete via PUT (no DELETE) ---
+console.log('\nCheck 2: cli.js forget testId (soft-delete via PUT)');
+{
+  const r = runBun(['scripts/cli.js', 'forget', 'testId'], { HONCHO_DRY_RUN: '1' });
+  assert(r.exitCode === 0, 'cli.js forget testId exits 0');
+  // stdout must NOT contain HTTP method "DELETE" as a method value
+  // (verifies soft-delete via PUT, not HTTP DELETE)
+  // Note: "deleted":true in JSON is acceptable — only "method":"DELETE" would indicate wrong implementation
+  const stdoutHasDeleteMethod =
+    r.stdout.includes('"method": "DELETE"') ||
+    r.stdout.includes('"method":"DELETE"');
+  assert(!stdoutHasDeleteMethod, 'cli.js forget stdout does NOT contain "method":"DELETE" (soft-delete via PUT confirmed)');
+  // stdout should confirm PUT method
+  const hasPutMethod = r.stdout.includes('"method": "PUT"') || r.stdout.includes('"method":"PUT"');
+  assert(hasPutMethod, 'cli.js forget stdout contains "method": "PUT"');
+}
+
+// --- Check 3: on-prompt-submit.js in dry-run with generic stdin ---
+console.log('\nCheck 3: on-prompt-submit.js dry-run with generic stdin');
+{
+  const r = runBun(
+    ['hooks/on-prompt-submit.js'],
+    { HONCHO_DRY_RUN: '1' },
+    JSON.stringify({ prompt: 'What is the capital of France?' })
+  );
+  assert(r.exitCode === 0, 'on-prompt-submit.js dry-run exits 0');
+}
+
+console.log(`\nResults: ${passed} passed, ${failed} failed`);
+process.exit(failed > 0 ? 1 : 0);