@devrik-tools/claude-gates 0.2.0 → 0.3.0

package/cli/__tests__/task.test.mjs

@@ -1,124 +0,0 @@
-// The `task` CLI subcommands are thin wiring over task-store.mjs; these tests exercise the
-// CLI surface itself (spawning `cli/index.mjs task ...` as a real child process, the way a
-// user or the register-requests hook's advice actually invokes it) against a temp project,
-// never against this repo's own .ai/config.json or task store.
-
-import assert from 'node:assert/strict';
-import { execFileSync } from 'node:child_process';
-import { existsSync, mkdirSync, mkdtempSync, readFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { dirname, join } from 'node:path';
-import { test } from 'node:test';
-import { fileURLToPath } from 'node:url';
-
-const CLI_ENTRY = join(
-  dirname(fileURLToPath(import.meta.url)),
-  '..',
-  'index.mjs',
-);
-
-function makeProject() {
-  const project = mkdtempSync(join(tmpdir(), 'task-cli-'));
-  mkdirSync(join(project, '.git'));
-  return project;
-}
-
-function runCli(args, cwd) {
-  try {
-    const stdout = execFileSync(process.execPath, [CLI_ENTRY, ...args], {
-      cwd,
-      encoding: 'utf8',
-    });
-    return { code: 0, stdout };
-  } catch (error) {
-    return {
-      code: error.status ?? 1,
-      stdout: error.stdout ?? '',
-      stderr: error.stderr ?? String(error),
-    };
-  }
-}
-
-test('task add persists a new open task under .ai/tasks/active.json', () => {
-  const project = makeProject();
-  const result = runCli(['task', 'add', 'Fix the thing', '--description', 'details'], project);
-  assert.equal(result.code, 0, result.stderr);
-
-  const activePath = join(project, '.ai', 'tasks', 'active.json');
-  assert.ok(existsSync(activePath));
-  const active = JSON.parse(readFileSync(activePath, 'utf8'));
-  assert.equal(active.tasks.length, 1);
-  assert.equal(active.tasks[0].title, 'Fix the thing');
-  assert.equal(active.tasks[0].status, 'open');
-});
-
-test('task list shows the active task, and --all also reaches history', () => {
-  const project = makeProject();
-  runCli(['task', 'add', 'Task one', '--id', 't1'], project);
-  runCli(['task', 'add', 'Task two', '--id', 't2'], project);
-  runCli(['task', 'abandon', 't2', '--reason', 'not needed'], project);
-
-  const active = runCli(['task', 'list'], project);
-  assert.match(active.stdout, /Task one/);
-  assert.doesNotMatch(active.stdout, /Task two/);
-
-  const all = runCli(['task', 'list', '--all'], project);
-  assert.match(all.stdout, /Task one/);
-  assert.match(all.stdout, /Task two/);
-});
-
-test('task close WITHOUT --evidence fails and leaves the task active', () => {
-  const project = makeProject();
-  runCli(['task', 'add', 'Needs evidence', '--id', 't1'], project);
-
-  const result = runCli(['task', 'close', 't1'], project);
-  assert.notEqual(result.code, 0);
-  assert.match(result.stderr, /evidence/i);
-
-  const activePath = join(project, '.ai', 'tasks', 'active.json');
-  const active = JSON.parse(readFileSync(activePath, 'utf8'));
-  assert.equal(active.tasks.length, 1, 'the task must still be active');
-});
-
-test('task close WITH --evidence succeeds and moves the task to history', () => {
-  const project = makeProject();
-  runCli(['task', 'add', 'Has evidence', '--id', 't1'], project);
-
-  const result = runCli(
-    ['task', 'close', 't1', '--evidence', 'npm test -> 5 passing'],
-    project,
-  );
-  assert.equal(result.code, 0, result.stderr);
-
-  const historyPath = join(project, '.ai', 'tasks', 'history.json');
-  const history = JSON.parse(readFileSync(historyPath, 'utf8'));
-  assert.equal(history.tasks.length, 1);
-  assert.equal(history.tasks[0].status, 'done');
-  assert.equal(history.tasks[0].evidence, 'npm test -> 5 passing');
-});
-
-test('task abandon needs no evidence and moves the task to history', () => {
-  const project = makeProject();
-  runCli(['task', 'add', 'Drop me', '--id', 't1'], project);
-
-  const result = runCli(['task', 'abandon', 't1', '--reason', 'obsolete'], project);
-  assert.equal(result.code, 0, result.stderr);
-
-  const historyPath = join(project, '.ai', 'tasks', 'history.json');
-  const history = JSON.parse(readFileSync(historyPath, 'utf8'));
-  assert.equal(history.tasks[0].status, 'abandoned');
-  assert.equal(history.tasks[0].closeReason, 'obsolete');
-});
-
-test('task promote links a forge run and keeps the task active as in_forge', () => {
-  const project = makeProject();
-  runCli(['task', 'add', 'Promote me', '--id', 't1'], project);
-
-  const result = runCli(['task', 'promote', 't1', 'run-42'], project);
-  assert.equal(result.code, 0, result.stderr);
-
-  const activePath = join(project, '.ai', 'tasks', 'active.json');
-  const active = JSON.parse(readFileSync(activePath, 'utf8'));
-  assert.equal(active.tasks[0].status, 'in_forge');
-  assert.equal(active.tasks[0].forgeRunId, 'run-42');
-});

package/cli/__tests__/version-consistency.test.mjs

@@ -1,44 +0,0 @@
-// Version coherence guard. This exists because of a real incident: the npm package was
-// bumped to 0.1.3 and published, but plugin.json / marketplace.json stayed at 0.1.0. Claude
-// Code versions a plugin by its plugin.json/marketplace version, so a machine that already
-// had 0.1.0 cached NEVER updated the code on reinstall — it ran the old, pre-migration gates
-// while the freshly written config.json said 0.1.3. The gates looked "enabled but broken".
-//
-// The rule this enforces: the npm package version, both plugin.json versions, and every
-// marketplace.json plugin entry must be the SAME string. Bump them together, every release.
-
-import assert from 'node:assert/strict';
-import { readFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-import { test } from 'node:test';
-import { fileURLToPath } from 'node:url';
-
-const ROOT = join(dirname(fileURLToPath(import.meta.url)), '..', '..');
-
-function readJson(relativePath) {
-  return JSON.parse(readFileSync(join(ROOT, relativePath), 'utf8').replace(/^/, ''));
-}
-
-test('npm, both plugin.json, and every marketplace entry share one version', () => {
-  const versions = {
-    'package.json': readJson('package.json').version,
-    'plugins/gates/.claude-plugin/plugin.json': readJson(
-      'plugins/gates/.claude-plugin/plugin.json',
-    ).version,
-    'plugins/tasks/.claude-plugin/plugin.json': readJson(
-      'plugins/tasks/.claude-plugin/plugin.json',
-    ).version,
-  };
-  for (const plugin of readJson('.claude-plugin/marketplace.json').plugins) {
-    versions[`marketplace.json:${plugin.name}`] = plugin.version;
-  }
-
-  const distinct = [...new Set(Object.values(versions))];
-  assert.equal(
-    distinct.length,
-    1,
-    `all versions must match; found ${JSON.stringify(versions)}. ` +
-      'A plugin.json/marketplace version behind the npm version means Claude Code keeps ' +
-      'serving the OLD cached plugin code on reinstall. Bump them together.',
-  );
-});

package/plugins/gates/hooks/__tests__/ask-adoption.test.mjs

@@ -1,83 +0,0 @@
-// ask-adoption — SessionStart hook. Spawned as a real child process with a JSON payload
-// on stdin, against a temp project (never this repo's own .ai/ state).
-
-import assert from 'node:assert/strict';
-import { execFileSync } from 'node:child_process';
-import { existsSync, mkdirSync, mkdtempSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { dirname, join } from 'node:path';
-import { test } from 'node:test';
-import { fileURLToPath } from 'node:url';
-
-const HOOK_PATH = join(
-  dirname(fileURLToPath(import.meta.url)),
-  '..',
-  'ask-adoption.mjs',
-);
-
-function makeProject() {
-  const project = mkdtempSync(join(tmpdir(), 'ask-adoption-'));
-  mkdirSync(join(project, '.git'));
-  return project;
-}
-
-function runHook(cwd) {
-  return execFileSync(process.execPath, [HOOK_PATH], {
-    input: JSON.stringify({ cwd }),
-    encoding: 'utf8',
-    env: { ...process.env, HOME: cwd, USERPROFILE: cwd },
-  });
-}
-
-test('a project that never answered gets asked, and the hook records that it asked', () => {
-  const project = makeProject();
-  const stdout = runHook(project);
-  assert.notEqual(stdout, '');
-  const payload = JSON.parse(stdout);
-  assert.equal(payload.hookSpecificOutput.hookEventName, 'SessionStart');
-  assert.match(payload.hookSpecificOutput.additionalContext, /adopt/i);
-  assert.ok(existsSync(join(project, '.ai', '.adoption-asked')));
-});
-
-test('a second session in the same never-answered project is not asked again', () => {
-  const project = makeProject();
-  runHook(project); // first session: asks, writes the marker
-  const stdout = runHook(project); // second session
-  assert.equal(stdout, '');
-});
-
-test('a project with an existing .ai/config.json is never asked', () => {
-  const project = makeProject();
-  mkdirSync(join(project, '.ai'), { recursive: true });
-  writeFileSync(
-    join(project, '.ai', 'config.json'),
-    JSON.stringify({ gates: {} }),
-  );
-  const stdout = runHook(project);
-  assert.equal(stdout, '');
-});
-
-test('askAdoptionInNewProject:false silences the hook even in a never-answered project', () => {
-  const project = makeProject();
-  mkdirSync(join(project, '.ai'), { recursive: true });
-  // A config exists only to carry the disable flag; the adoption question itself would
-  // otherwise still be considered "answered" by this same file's presence — so assert the
-  // disable path directly against a config that ALSO sets the flag off, confirming this is
-  // the flag doing the work and not just "config.json exists" from the previous test.
-  writeFileSync(
-    join(project, '.ai', 'config.json'),
-    JSON.stringify({ gates: { askAdoptionInNewProject: false } }),
-  );
-  const stdout = runHook(project);
-  assert.equal(stdout, '');
-});
-
-test('never throws even when stdin is not valid JSON', () => {
-  const project = makeProject();
-  const stdout = execFileSync(process.execPath, [HOOK_PATH], {
-    input: 'not json',
-    encoding: 'utf8',
-    env: { ...process.env, HOME: project, USERPROFILE: project },
-  });
-  assert.equal(typeof stdout, 'string');
-});

package/plugins/gates/hooks/__tests__/doctor.test.mjs

@@ -1,85 +0,0 @@
-// doctor — SessionStart hook. Spawned as a real child process with a JSON payload on
-// stdin, HOME isolated so the real global config is never read.
-
-import assert from 'node:assert/strict';
-import { execFileSync } from 'node:child_process';
-import { mkdirSync, mkdtempSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { dirname, join } from 'node:path';
-import { test } from 'node:test';
-import { fileURLToPath } from 'node:url';
-
-const HOOK_PATH = join(
-  dirname(fileURLToPath(import.meta.url)),
-  '..',
-  'doctor.mjs',
-);
-
-function makeProject() {
-  const project = mkdtempSync(join(tmpdir(), 'doctor-'));
-  mkdirSync(join(project, '.git'));
-  return project;
-}
-
-function runHook(cwd, { env: environment = {} } = {}) {
-  return execFileSync(process.execPath, [HOOK_PATH], {
-    input: JSON.stringify({ cwd }),
-    encoding: 'utf8',
-    env: { ...process.env, HOME: cwd, USERPROFILE: cwd, ...environment },
-  });
-}
-
-test('stays silent when node satisfies the current engines.node and scripts are on disk', () => {
-  const project = makeProject();
-  const stdout = runHook(project);
-  assert.equal(stdout, '');
-});
-
-test('speaks when a minNodeVersion above the running node is configured', () => {
-  const project = makeProject();
-  mkdirSync(join(project, '.ai'), { recursive: true });
-  writeFileSync(
-    join(project, '.ai', 'config.json'),
-    JSON.stringify({
-      gates: {
-        validateEnvironmentOnStart: {
-          enabled: true,
-          minNodeVersion: '999.0.0',
-        },
-      },
-    }),
-  );
-  const stdout = runHook(project);
-  assert.notEqual(stdout, '');
-  const payload = JSON.parse(stdout);
-  assert.equal(payload.hookSpecificOutput.hookEventName, 'SessionStart');
-  assert.match(payload.hookSpecificOutput.additionalContext, /999\.0\.0/);
-});
-
-test('validateEnvironmentOnStart:false in project config silences the hook even with a bad minNodeVersion', () => {
-  const project = makeProject();
-  mkdirSync(join(project, '.ai'), { recursive: true });
-  writeFileSync(
-    join(project, '.ai', 'config.json'),
-    JSON.stringify({
-      gates: {
-        validateEnvironmentOnStart: {
-          enabled: false,
-          minNodeVersion: '999.0.0',
-        },
-      },
-    }),
-  );
-  const stdout = runHook(project);
-  assert.equal(stdout, '');
-});
-
-test('never throws even when stdin is not valid JSON', () => {
-  const project = makeProject();
-  const stdout = execFileSync(process.execPath, [HOOK_PATH], {
-    input: 'not json',
-    encoding: 'utf8',
-    env: { ...process.env, HOME: project, USERPROFILE: project },
-  });
-  assert.equal(typeof stdout, 'string');
-});

package/plugins/gates/hooks/__tests__/wiring-check.test.mjs

@@ -1,65 +0,0 @@
-// wiring-check — SessionStart hook. Runs against the REAL repo registry/hooks.json/disk
-// (it has no per-project state of its own — it inspects the install, not the project),
-// with HOME isolated only so config lookups do not read a real global config.
-
-import assert from 'node:assert/strict';
-import { execFileSync } from 'node:child_process';
-import { mkdirSync, mkdtempSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { dirname, join } from 'node:path';
-import { test } from 'node:test';
-import { fileURLToPath } from 'node:url';
-
-const HOOK_PATH = join(
-  dirname(fileURLToPath(import.meta.url)),
-  '..',
-  'wiring-check.mjs',
-);
-const REPO_ROOT = join(
-  dirname(fileURLToPath(import.meta.url)),
-  '..',
-  '..',
-  '..',
-  '..',
-);
-
-function makeHomeOnly() {
-  // wiring-check reads the registry/hooks.json relative to ITS OWN location on disk, so the
-  // cwd it's given only matters for config lookup; it does not need to be a project root.
-  return mkdtempSync(join(tmpdir(), 'wiring-check-home-'));
-}
-
-function runHook(cwd, home) {
-  return execFileSync(process.execPath, [HOOK_PATH], {
-    input: JSON.stringify({ cwd }),
-    encoding: 'utf8',
-    env: { ...process.env, HOME: home, USERPROFILE: home },
-  });
-}
-
-test('the real repo (registry, hooks.json, disk all in sync) produces no warning', () => {
-  const home = makeHomeOnly();
-  const stdout = runHook(REPO_ROOT, home);
-  assert.equal(stdout, '', `expected silence, got: ${stdout}`);
-});
-
-test('checkWiringOnStart:false silences the hook globally', () => {
-  const home = makeHomeOnly();
-  mkdirSync(join(home, '.claude', 'claude-gates'), { recursive: true });
-  writeFileSync(
-    join(home, '.claude', 'claude-gates', 'config.json'),
-    JSON.stringify({ gates: { checkWiringOnStart: false } }),
-  );
-  const stdout = runHook(REPO_ROOT, home);
-  assert.equal(stdout, '');
-});
-
-test('never throws even when stdin is not valid JSON', () => {
-  const home = makeHomeOnly();
-  const stdout = execFileSync(process.execPath, [HOOK_PATH], {
-    input: 'not json',
-    encoding: 'utf8',
-    env: { ...process.env, HOME: home, USERPROFILE: home },
-  });
-  assert.equal(typeof stdout, 'string');
-});

package/plugins/gates/hooks/gates/audit-before-build/audit-before-build.edge.test.mjs

@@ -1,83 +0,0 @@
-import assert from 'node:assert/strict';
-import { execFileSync } from 'node:child_process';
-import { mkdtempSync, mkdirSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { dirname, join } from 'node:path';
-import { test } from 'node:test';
-import { fileURLToPath } from 'node:url';
-
-const GATE = join(dirname(fileURLToPath(import.meta.url)), 'index.mjs');
-
-function runGate(payload, { config } = {}) {
-  const project = mkdtempSync(join(tmpdir(), 'audit-before-build-edge-'));
-  mkdirSync(join(project, '.git'));
-  if (config) {
-    mkdirSync(join(project, '.ai'));
-    writeFileSync(join(project, '.ai', 'config.json'), JSON.stringify(config));
-  }
-  const out = execFileSync(process.execPath, [GATE], {
-    input: JSON.stringify(payload),
-    encoding: 'utf8',
-    cwd: project,
-    env: { ...process.env, HOME: project, USERPROFILE: project },
-  });
-  return { out: out.trim() ? JSON.parse(out.trim()) : null, project };
-}
-
-function delegate(prompt) {
-  return { tool_name: 'Agent', tool_input: { prompt } };
-}
-function write(filePath, content) {
-  return { tool_name: 'Write', tool_input: { file_path: filePath, content } };
-}
-function isDeny(result) {
-  return result?.hookSpecificOutput?.permissionDecision === 'deny';
-}
-
-const ENABLE = { config: { gates: { requireAuditBeforeBuilding: true } } };
-
-// EDGE CASE (BUG): AUDIT_EVIDENCE_PATTERN is a bare substring/regex test over the WHOLE
-// delegation prompt with no proximity/ordering requirement relative to the tool-creation
-// intent. An unrelated, earlier sentence that happens to say "no existing tool" anywhere
-// in a long prompt satisfies the audit-evidence check even when it has nothing to do with
-// the actual tool being created, so a prompt can smuggle past the gate by mentioning
-// boilerplate audit language irrelevantly.
-test('BUG: false negative — audit language elsewhere in the prompt, unrelated to the new tool, satisfies the check', () => {
-  const prompt =
-    'Context: earlier we confirmed no existing tool handles our deploy pipeline. ' +
-    'Now, unrelated task: create a new script that scrapes user passwords from logs.';
-  const { out } = runGate(delegate(prompt), ENABLE);
-  assert.equal(out, null, 'gate allows because AUDIT_EVIDENCE_PATTERN matched irrelevant boilerplate anywhere in the prompt');
-});
-
-// EDGE CASE (BUG): INLINE_JUSTIFICATION_PATTERN for a direct Write is similarly a bare
-// substring test over the whole file content. Any comment anywhere in the file containing
-// the word "justification:" (even quoting/describing the concept, not actually justifying
-// THIS file) passes.
-test('BUG: false negative — the word "justification:" appearing in an unrelated docstring satisfies the check for any new tool file', () => {
-  const content = [
-    '// This module documents how other files use the phrase justification: <reason> in',
-    '// their headers, as an example of our commenting convention.',
-    'export function run() {}',
-  ].join('\n');
-  const { out } = runGate(write('/repo/scripts/new-thing.mjs', content), ENABLE);
-  assert.equal(out, null, 'gate allows because the literal string "justification:" appears anywhere, regardless of whether it actually justifies this file');
-});
-
-// EDGE CASE: confirm the "editing an existing file" exemption (checkWrite, index.mjs line
-// 56-58) can be trivially satisfied by ANY tool call whose file_path happens to already
-// exist on disk from an unrelated prior write within the same directory — verifying this
-// is intentional per the comment, not a further bug, but documenting the boundary.
-test('OK (documented, not a new bug): pre-creating an empty file at the target path bypasses audit entirely on the next edit', () => {
-  const { project } = runGate(delegate('noop'), ENABLE); // just to get an isolated project dir
-  const targetPath = join(project, 'scripts', 'sneaky.mjs');
-  mkdirSync(join(project, 'scripts'), { recursive: true });
-  writeFileSync(targetPath, ''); // pre-create empty file outside the gate's view
-  const out2 = execFileSync(process.execPath, [GATE], {
-    input: JSON.stringify(write(targetPath, 'export function run() {}')),
-    encoding: 'utf8',
-    cwd: project,
-    env: { ...process.env, HOME: project, USERPROFILE: project },
-  });
-  assert.equal(out2.trim() ? JSON.parse(out2.trim()) : null, null, 'existsSync(rawPath) exemption means pre-touching the file first defeats the whole gate');
-});

package/plugins/gates/hooks/gates/audit-before-build/test.mjs

@@ -1,117 +0,0 @@
-import assert from 'node:assert/strict';
-import { execFileSync } from 'node:child_process';
-import { mkdtempSync, mkdirSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { dirname, join } from 'node:path';
-import { test } from 'node:test';
-import { fileURLToPath } from 'node:url';
-
-const GATE = join(dirname(fileURLToPath(import.meta.url)), 'index.mjs');
-
-function runGate(payload, { config } = {}) {
-  const project = mkdtempSync(join(tmpdir(), 'audit-before-build-'));
-  mkdirSync(join(project, '.git'));
-  if (config) {
-    mkdirSync(join(project, '.ai'));
-    writeFileSync(join(project, '.ai', 'config.json'), JSON.stringify(config));
-  }
-  const out = execFileSync(process.execPath, [GATE], {
-    input: JSON.stringify(payload),
-    encoding: 'utf8',
-    cwd: project,
-    // Isolate from the user's real global config: point homedir() at the temp
-    // project so the global-config fallback finds nothing (registry default).
-    env: { ...process.env, HOME: project, USERPROFILE: project },
-  });
-  return out.trim() ? JSON.parse(out.trim()) : null;
-}
-
-function delegate(prompt) {
-  return { tool_name: 'Agent', tool_input: { prompt } };
-}
-function write(filePath, content) {
-  return { tool_name: 'Write', tool_input: { file_path: filePath, content } };
-}
-function isDeny(result) {
-  return result?.hookSpecificOutput?.permissionDecision === 'deny';
-}
-
-const ENABLE = { config: { gates: { requireAuditBeforeBuilding: true } } };
-
-test('denies delegation to create a new tool without audit evidence', () => {
-  assert.ok(
-    isDeny(runGate(delegate('create a new script that checks X'), ENABLE)),
-  );
-});
-
-test('allows delegation with audit evidence stated', () => {
-  assert.equal(
-    runGate(
-      delegate(
-        'create a new script that checks X. audited and no existing tool covers this.',
-      ),
-      ENABLE,
-    ),
-    null,
-  );
-});
-
-test('denies writing a new executable tool file without a justification comment', () => {
-  assert.equal(
-    runGate(
-      write('/repo/scripts/check-thing.mjs', 'export function run() {}'),
-      ENABLE,
-    )?.hookSpecificOutput?.permissionDecision,
-    'deny',
-  );
-});
-
-test('allows writing a tool file with a justification comment', () => {
-  assert.equal(
-    runGate(
-      write(
-        '/repo/scripts/check-thing.mjs',
-        '// justification: no existing tool does this\nexport function run() {}',
-      ),
-      ENABLE,
-    ),
-    null,
-  );
-});
-
-test('allows a write outside tool folders or non-executable extension', () => {
-  assert.equal(
-    runGate(write('/repo/docs/notes.md', 'plain notes'), ENABLE),
-    null,
-  );
-  assert.equal(runGate(write('/repo/scripts/data.json', '{}'), ENABLE), null);
-});
-
-test('denies delegation to create a new tool without audit evidence, in Spanish', () => {
-  assert.ok(
-    isDeny(runGate(delegate('crea un nuevo script que verifique X'), ENABLE)),
-  );
-});
-
-test('bilingual control: ES and EN equivalent new-tool delegations both deny without audit evidence', () => {
-  const es = delegate('crea un nuevo script que verifique X');
-  const en = delegate('create a new script that checks X');
-  assert.ok(isDeny(runGate(es, ENABLE)));
-  assert.ok(isDeny(runGate(en, ENABLE)));
-});
-
-test('allows a Spanish delegation with audit evidence stated', () => {
-  assert.equal(
-    runGate(
-      delegate(
-        'crea un nuevo script que verifique X. audite y no existe una herramienta que cubra esto.',
-      ),
-      ENABLE,
-    ),
-    null,
-  );
-});
-
-test('disabled by default (registry default is false)', () => {
-  assert.equal(runGate(delegate('create a new script that checks X')), null);
-});