@devrik-tools/claude-gates 0.2.0 → 0.3.0

package/plugins/gates/hooks/lib/__tests__/signals.test.mjs

@@ -1,114 +0,0 @@
-import assert from 'node:assert/strict';
-import { test } from 'node:test';
-import {
-  RISK_SIGNAL,
-  MONEY_SIGNAL,
-  AUTH_SIGNAL,
-  DESTRUCTIVE_DEPLOY_SIGNAL,
-  CONJECTURE,
-  PERSISTENCE_VERB,
-  withUnicodeWordBoundary,
-} from '../signals.mjs';
-
-// ── RISK_SIGNAL ──────────────────────────────────────────────────────────────────────
-
-test('RISK_SIGNAL matches money terms in EN and ES', () => {
-  assert.ok(RISK_SIGNAL.test('update the payment flow'));
-  assert.ok(RISK_SIGNAL.test('actualizar el flujo de pago'));
-  assert.ok(RISK_SIGNAL.test('mover el saldo de una cuenta'));
-  assert.ok(RISK_SIGNAL.test('move the account balance'));
-});
-
-test('RISK_SIGNAL matches auth terms in EN and ES', () => {
-  assert.ok(RISK_SIGNAL.test('reset the user password'));
-  assert.ok(RISK_SIGNAL.test('resetear la contrasena del usuario'));
-  assert.ok(RISK_SIGNAL.test('resetear la contraseña del usuario'));
-  assert.ok(RISK_SIGNAL.test('cambiar la sesion activa'));
-  assert.ok(RISK_SIGNAL.test('cambiar la sesión activa'));
-});
-
-test('RISK_SIGNAL matches destructive/deploy terms in EN and ES', () => {
-  assert.ok(RISK_SIGNAL.test('deploy to production'));
-  assert.ok(RISK_SIGNAL.test('desplegar a produccion'));
-  assert.ok(RISK_SIGNAL.test('truncate the orders table'));
-  assert.ok(RISK_SIGNAL.test('eliminar la tabla de pedidos'));
-  assert.ok(RISK_SIGNAL.test('run the migration'));
-  assert.ok(RISK_SIGNAL.test('correr la migracion'));
-});
-
-test('bilingual control: an ES risk brief matches exactly like its EN equivalent', () => {
-  const es = 'implementa el endpoint para mover el saldo de una cuenta bancaria';
-  const en = 'implement the endpoint to move the balance of a bank account';
-  assert.equal(RISK_SIGNAL.test(es), RISK_SIGNAL.test(en));
-  assert.ok(RISK_SIGNAL.test(es));
-});
-
-test('RISK_SIGNAL does not fire on neutral text', () => {
-  assert.equal(RISK_SIGNAL.test('add a tooltip to the button'), false);
-  assert.equal(RISK_SIGNAL.test('agregar un tooltip al boton'), false);
-});
-
-test('RISK_SIGNAL false-positive guard: short terms require a full word', () => {
-  // "auth" inside "autor", "prod" inside "producto", "token" inside "tokenizer".
-  assert.equal(RISK_SIGNAL.test('the autor of this book'), false);
-  assert.equal(RISK_SIGNAL.test('el autor de este libro'), false);
-  assert.equal(RISK_SIGNAL.test('compra este producto'), false);
-  assert.equal(RISK_SIGNAL.test('buy this product'), false);
-  assert.equal(RISK_SIGNAL.test('the tokenizer splits words'), false);
-});
-
-test('MONEY_SIGNAL / AUTH_SIGNAL / DESTRUCTIVE_DEPLOY_SIGNAL are independently usable', () => {
-  assert.ok(MONEY_SIGNAL.test('pago'));
-  assert.equal(MONEY_SIGNAL.test('auth'), false);
-  assert.ok(AUTH_SIGNAL.test('token'));
-  assert.equal(AUTH_SIGNAL.test('pago'), false);
-  assert.ok(DESTRUCTIVE_DEPLOY_SIGNAL.test('produccion'));
-  assert.equal(DESTRUCTIVE_DEPLOY_SIGNAL.test('pago'), false);
-});
-
-// ── CONJECTURE ───────────────────────────────────────────────────────────────────────
-
-test('CONJECTURE matches EN and ES conjecture phrasing', () => {
-  assert.ok(CONJECTURE.test('i assume the timezone is UTC'));
-  assert.ok(CONJECTURE.test('probably fine to skip this'));
-  assert.ok(CONJECTURE.test('supongo que esto funciona'));
-  assert.ok(CONJECTURE.test('asumo que el usuario ya esta logueado'));
-  assert.ok(CONJECTURE.test('deberia ser suficiente con esto'));
-  assert.ok(CONJECTURE.test('debería ser suficiente con esto'));
-  assert.ok(CONJECTURE.test('creo que esto anda bien'));
-});
-
-test('bilingual control: ES and EN conjecture brief both trigger', () => {
-  const es = 'creo que el usuario ya esta autenticado, no lo verifique';
-  const en = 'i assume the user is already authenticated, did not verify it';
-  assert.equal(CONJECTURE.test(es), CONJECTURE.test(en));
-  assert.ok(CONJECTURE.test(es));
-});
-
-test('CONJECTURE does not fire on neutral confirmed statements', () => {
-  assert.equal(CONJECTURE.test('verified: the timezone is UTC per config.json'), false);
-  assert.equal(CONJECTURE.test('confirmado: el usuario esta autenticado'), false);
-});
-
-// ── PERSISTENCE_VERB ─────────────────────────────────────────────────────────────────
-
-test('PERSISTENCE_VERB matches EN and ES persistence instructions', () => {
-  assert.ok(PERSISTENCE_VERB.test('save this to state.json'));
-  assert.ok(PERSISTENCE_VERB.test('guarda esto en decision.md'));
-  assert.ok(PERSISTENCE_VERB.test('persist the result in the database'));
-  assert.ok(PERSISTENCE_VERB.test('escribi esto en el archivo'));
-  assert.ok(PERSISTENCE_VERB.test('anota el resultado en el log'));
-});
-
-test('PERSISTENCE_VERB does not fire on unrelated prose', () => {
-  assert.equal(PERSISTENCE_VERB.test('the button looks nice'), false);
-  assert.equal(PERSISTENCE_VERB.test('el boton se ve bien'), false);
-});
-
-// ── withUnicodeWordBoundary ──────────────────────────────────────────────────────────
-
-test('withUnicodeWordBoundary rejects a substring match', () => {
-  const pattern = withUnicodeWordBoundary('auth');
-  assert.ok(pattern.test('auth required'));
-  assert.equal(pattern.test('autor'), false);
-});

package/plugins/gates/hooks/lib/hook-io-config.edge.test.mjs

@@ -1,189 +0,0 @@
-// Edge audit for the common scaffolding (hook-io.mjs, config.mjs) that every gate shares.
-// Uses a minimal real gate built on runGate() so behavior is exercised end to end rather
-// than by reading source and guessing.
-//
-// Findings:
-//   1. Config precedence: a project config that EXISTS but omits a given gate key falls
-//      through to the REGISTRY DEFAULT passed by the gate (not to the global config) --
-//      confirmed by gatesLayerFor's early return the moment projectData is truthy
-//      (config.mjs line 80-81: `if (projectData) return projectData.gates ?? {};`). A
-//      global config with the key enabled is never consulted once a project config file
-//      exists at all, even if it says nothing about this particular gate.
-//   2. A corrupted project config.json does NOT silently disable protection: readJsonOrNull
-//      returns null on parse failure, gatesLayerFor then falls through to the global config
-//      layer, and if that too is corrupt/absent, isGateEnabled falls back to the gate's own
-//      registryDefault. Verified with a gate whose registryDefault is `true` (deny-by-default)
-//      to prove corruption doesn't fail open when the default is protective.
-//   3. toolNameOf/runGate coalescing (payload.tool_name ?? payload.name ?? '' -> '' on
-//      unparseable JSON) is exercised directly here against the shared helpers, independent
-//      of any specific gate's matcher set.
-
-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, pathToFileURL } from 'node:url';
-
-const HERE = dirname(fileURLToPath(import.meta.url));
-
-// A minimal probe gate: denies unconditionally whenever it runs and is enabled, with a
-// registryDefault of true (protective/deny-by-default), so we can distinguish "ran and
-// allowed via toolName mismatch" from "did not run because disabled".
-const PROBE_GATE_SOURCE = `
-import { runGate, deny } from ${JSON.stringify(pathToFileURL(join(HERE, 'hook-io.mjs')).href)};
-runGate(
-  { id: 'probe-gate', configKey: 'probeGate', enabledByDefault: true },
-  ({ toolName }) => {
-    deny('probe-gate', 'toolName=' + JSON.stringify(toolName));
-  },
-);
-`;
-
-function writeProbeGate(directory) {
-  const gatePath = join(directory, 'probe-gate.mjs');
-  writeFileSync(gatePath, PROBE_GATE_SOURCE);
-  return gatePath;
-}
-
-function runProbe(gatePath, rawInput, project) {
-  const out = execFileSync(process.execPath, [gatePath], {
-    input: rawInput,
-    encoding: 'utf8',
-    cwd: project,
-    env: { ...process.env, HOME: project, USERPROFILE: project },
-  });
-  return out.trim() ? JSON.parse(out.trim()) : null;
-}
-
-function isDeny(result) {
-  return result?.hookSpecificOutput?.permissionDecision === 'deny';
-}
-
-test('toolNameOf/runGate: unparseable JSON payload coalesces toolName to empty string, not null', () => {
-  const scratch = mkdtempSync(join(tmpdir(), 'hookio-edge-'));
-  const project = mkdtempSync(join(tmpdir(), 'hookio-proj-'));
-  mkdirSync(join(project, '.git'));
-  const gatePath = writeProbeGate(scratch);
-  // registryDefault=true means the probe gate is ON with no config at all; it always denies
-  // when it runs, and the deny message embeds the resolved toolName so we can inspect it.
-  const result = runProbe(gatePath, 'not json at all {{{', project);
-  assert.ok(isDeny(result));
-  assert.match(
-    result.hookSpecificOutput.permissionDecisionReason,
-    /toolName=""/,
-    'confirms toolNameOf(...) ?? \'\' resolves corrupt payloads to the empty string, ' +
-      'the exact value that fails to match any TOOL_GROUPS Set',
-  );
-});
-
-test('config precedence: project config exists but omits the gate key -> registryDefault wins, NOT global config', () => {
-  const project = mkdtempSync(join(tmpdir(), 'hookio-proj-'));
-  mkdirSync(join(project, '.git'));
-  mkdirSync(join(project, '.ai'));
-  // Project config exists, and declares gates, but never mentions 'probeGate'.
-  writeFileSync(
-    join(project, '.ai', 'config.json'),
-    JSON.stringify({ gates: { someOtherGate: true } }),
-  );
-  // Global config (same HOME as project, since HOME=project below) explicitly disables it.
-  // If precedence were "most specific explicit setting wins", global's false should apply.
-  // If precedence is "project file existing short-circuits global entirely", the probe's
-  // own registryDefault (true) should apply instead, ignoring global.
-  const home = project; // isolate HOME to a dir we control, distinct from project root marker use
-  mkdirSync(join(home, '.claude', 'claude-gates'), { recursive: true });
-  writeFileSync(
-    join(home, '.claude', 'claude-gates', 'config.json'),
-    JSON.stringify({ gates: { probeGate: false } }),
-  );
-  const scratch = mkdtempSync(join(tmpdir(), 'hookio-edge-'));
-  const gatePath = writeProbeGate(scratch);
-  const out = execFileSync(process.execPath, [gatePath], {
-    input: JSON.stringify({ tool_name: 'Write', tool_input: {} }),
-    encoding: 'utf8',
-    cwd: project,
-    env: { ...process.env, HOME: home, USERPROFILE: home },
-  });
-  const result = out.trim() ? JSON.parse(out.trim()) : null;
-  assert.ok(
-    isDeny(result),
-    'PASA(confirmed): project config existing makes gatesLayerFor return early with {} ' +
-      'for gates it does not mention, so registryDefault (true/deny) wins over the global ' +
-      'config saying false -- global is never consulted once ANY project config.json exists',
-  );
-});
-
-test('config precedence: NO project config at all -> global config value is honored', () => {
-  const project = mkdtempSync(join(tmpdir(), 'hookio-proj-'));
-  mkdirSync(join(project, '.git'));
-  // No .ai/config.json in the project at all.
-  const home = mkdtempSync(join(tmpdir(), 'hookio-home-'));
-  mkdirSync(join(home, '.claude', 'claude-gates'), { recursive: true });
-  writeFileSync(
-    join(home, '.claude', 'claude-gates', 'config.json'),
-    JSON.stringify({ gates: { probeGate: false } }),
-  );
-  const scratch = mkdtempSync(join(tmpdir(), 'hookio-edge-'));
-  const gatePath = writeProbeGate(scratch);
-  const out = execFileSync(process.execPath, [gatePath], {
-    input: JSON.stringify({ tool_name: 'Write', tool_input: {} }),
-    encoding: 'utf8',
-    cwd: project,
-    env: { ...process.env, HOME: home, USERPROFILE: home },
-  });
-  const result = out.trim() ? JSON.parse(out.trim()) : null;
-  assert.equal(
-    result,
-    null,
-    'control: with no project config file present at all, global config IS consulted and ' +
-      'its false correctly disables the gate -- confirms the precedence bug above is ' +
-      'specifically "project file exists" short-circuiting, not "global never works"',
-  );
-});
-
-test('corrupted project config.json does not silently disable a protective (default-on) gate', () => {
-  const project = mkdtempSync(join(tmpdir(), 'hookio-proj-'));
-  mkdirSync(join(project, '.git'));
-  mkdirSync(join(project, '.ai'));
-  writeFileSync(join(project, '.ai', 'config.json'), '{ this is not valid json ][');
-  const home = mkdtempSync(join(tmpdir(), 'hookio-home-'));
-  const scratch = mkdtempSync(join(tmpdir(), 'hookio-edge-'));
-  const gatePath = writeProbeGate(scratch);
-  const out = execFileSync(process.execPath, [gatePath], {
-    input: JSON.stringify({ tool_name: 'Write', tool_input: {} }),
-    encoding: 'utf8',
-    cwd: project,
-    env: { ...process.env, HOME: home, USERPROFILE: home },
-  });
-  const result = out.trim() ? JSON.parse(out.trim()) : null;
-  assert.ok(
-    isDeny(result),
-    'FALLA(ok): corrupt project config treated as absent -> falls through to global (none) ' +
-      '-> registryDefault (true) -> still protected, matching config.mjs\'s documented intent',
-  );
-});
-
-test('corrupted GLOBAL config.json (no project config) does not silently disable a protective gate', () => {
-  const project = mkdtempSync(join(tmpdir(), 'hookio-proj-'));
-  mkdirSync(join(project, '.git'));
-  const home = mkdtempSync(join(tmpdir(), 'hookio-home-'));
-  mkdirSync(join(home, '.claude', 'claude-gates'), { recursive: true });
-  writeFileSync(
-    join(home, '.claude', 'claude-gates', 'config.json'),
-    '{ not valid json at all',
-  );
-  const scratch = mkdtempSync(join(tmpdir(), 'hookio-edge-'));
-  const gatePath = writeProbeGate(scratch);
-  const out = execFileSync(process.execPath, [gatePath], {
-    input: JSON.stringify({ tool_name: 'Write', tool_input: {} }),
-    encoding: 'utf8',
-    cwd: project,
-    env: { ...process.env, HOME: home, USERPROFILE: home },
-  });
-  const result = out.trim() ? JSON.parse(out.trim()) : null;
-  assert.ok(
-    isDeny(result),
-    'FALLA(ok): corrupt global config also treated as absent -> registryDefault wins',
-  );
-});

package/plugins/tasks/hooks/__tests__/register-requests.test.mjs

@@ -1,100 +0,0 @@
-// register-requests — UserPromptSubmit hook. Spawned as a real child process, matching how
-// Claude Code invokes it, against a temp project.
-
-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';
-import { openTaskStore } from '../lib/task-store.mjs';
-
-const HOOK_PATH = join(
-  dirname(fileURLToPath(import.meta.url)),
-  '..',
-  'register-requests.mjs',
-);
-
-function makeProject() {
-  const project = mkdtempSync(join(tmpdir(), 'register-requests-'));
-  mkdirSync(join(project, '.git'));
-  return project;
-}
-
-function runHook(cwd) {
-  return execFileSync(process.execPath, [HOOK_PATH], {
-    input: JSON.stringify({ cwd }),
-    encoding: 'utf8',
-  });
-}
-
-function writeConfig(project, gates) {
-  mkdirSync(join(project, '.ai'), { recursive: true });
-  writeFileSync(join(project, '.ai', 'config.json'), JSON.stringify({ gates }));
-}
-
-function sampleTask(id) {
-  return {
-    id,
-    title: `task ${id}`,
-    description: '',
-    status: 'open',
-    size: 'trivial',
-    createdAt: new Date().toISOString(),
-    messages: [],
-  };
-}
-
-test('always asks the model to classify+register, even with no active tasks yet', () => {
-  const project = makeProject();
-  const stdout = runHook(project);
-  assert.match(stdout, /claude-gates task add/);
-});
-
-test('does NOT recite active tasks before remindEveryMessages is reached', () => {
-  const project = makeProject();
-  const store = openTaskStore(project);
-  store.add(sampleTask('t1'));
-  writeConfig(project, { remindOpenTasks: { enabled: true, remindEveryMessages: 3 } });
-
-  const first = runHook(project);
-  assert.doesNotMatch(first, /OPEN TASKS/);
-  const second = runHook(project);
-  assert.doesNotMatch(second, /OPEN TASKS/);
-});
-
-test('recites active tasks once remindEveryMessages is reached, then resets the counter', () => {
-  const project = makeProject();
-  const store = openTaskStore(project);
-  store.add(sampleTask('t1'));
-  writeConfig(project, { remindOpenTasks: { enabled: true, remindEveryMessages: 2 } });
-
-  runHook(project); // 1st call: counter -> 1, no reminder
-  const forced = runHook(project); // 2nd call: counter hits threshold -> reminder + reset
-  assert.match(forced, /OPEN TASKS/);
-  assert.match(forced, /t1/);
-
-  const afterReset = runHook(project); // 3rd call: counter just reset -> no reminder yet
-  assert.doesNotMatch(afterReset, /OPEN TASKS/);
-});
-
-test('remindOpenTasks:false silences the hook entirely (no classify prompt, no reminder)', () => {
-  const project = makeProject();
-  const store = openTaskStore(project);
-  store.add(sampleTask('t1'));
-  writeConfig(project, { remindOpenTasks: false });
-
-  const stdout = runHook(project);
-  assert.equal(stdout, '');
-});
-
-test('defaults-dump mode reports remindEveryMessages default without touching stdin', () => {
-  const out = execFileSync(process.execPath, [HOOK_PATH], {
-    encoding: 'utf8',
-    env: { ...process.env, CLAUDE_GATES_DUMP_DEFAULTS: '1' },
-  });
-  const parsed = JSON.parse(out);
-  assert.equal(parsed.configKey, 'remindOpenTasks');
-  assert.equal(parsed.defaultParams.remindEveryMessages, 5);
-});

package/plugins/tasks/hooks/__tests__/session-tasks.test.mjs

@@ -1,95 +0,0 @@
-// session-tasks — SessionStart hook. Spawned as a real child process with a JSON payload on
-// stdin, exactly as Claude Code invokes it, against a temp project (never this repo's own
-// .ai/ state).
-
-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';
-import { openTaskStore, STATUS } from '../lib/task-store.mjs';
-
-const HOOK_PATH = join(
-  dirname(fileURLToPath(import.meta.url)),
-  '..',
-  'session-tasks.mjs',
-);
-
-function makeProject() {
-  const project = mkdtempSync(join(tmpdir(), 'session-tasks-'));
-  mkdirSync(join(project, '.git'));
-  return project;
-}
-
-function runHook(cwd) {
-  return execFileSync(process.execPath, [HOOK_PATH], {
-    input: JSON.stringify({ cwd }),
-    encoding: 'utf8',
-  });
-}
-
-function sampleTask(id, status = STATUS.OPEN) {
-  return {
-    id,
-    title: `task ${id}`,
-    description: '',
-    status,
-    size: 'trivial',
-    createdAt: new Date().toISOString(),
-    messages: [],
-  };
-}
-
-test('stays silent (empty stdout) when there are no active tasks', () => {
-  const project = makeProject();
-  const stdout = runHook(project);
-  assert.equal(stdout, '');
-});
-
-test('lists active tasks (including in_forge, marked) when some exist', () => {
-  const project = makeProject();
-  const store = openTaskStore(project);
-  store.add(sampleTask('t1'));
-  store.add(sampleTask('t2', STATUS.IN_FORGE));
-
-  const stdout = runHook(project);
-  assert.notEqual(stdout, '');
-  const payload = JSON.parse(stdout);
-  const context = payload.hookSpecificOutput.additionalContext;
-  assert.match(context, /t1/);
-  assert.match(context, /t2/);
-  assert.match(context, /in_forge/);
-  assert.equal(payload.hookSpecificOutput.hookEventName, 'SessionStart');
-});
-
-test('a task closed (done/abandoned) does not appear in the session-start list', () => {
-  const project = makeProject();
-  const store = openTaskStore(project);
-  store.add(sampleTask('t1'));
-  store.add(sampleTask('t2'));
-  store.close('t2', STATUS.ABANDONED, { reason: 'dropped' });
-
-  const stdout = runHook(project);
-  const context = JSON.parse(stdout).hookSpecificOutput.additionalContext;
-  assert.match(context, /t1/);
-  assert.doesNotMatch(context, /t2/);
-});
-
-test('listTasksOnSessionStart:false in project config silences the hook even with active tasks', () => {
-  const project = makeProject();
-  const store = openTaskStore(project);
-  store.add(sampleTask('t1'));
-
-  mkdirSync(join(project, '.ai'), { recursive: true });
-  writeFileSync(
-    join(project, '.ai', 'config.json'),
-    JSON.stringify({
-      gates: { listTasksOnSessionStart: false },
-    }),
-  );
-
-  const stdout = runHook(project);
-  assert.equal(stdout, '');
-});

package/plugins/tasks/hooks/lib/__tests__/task-store.test.mjs

@@ -1,180 +0,0 @@
-import assert from 'node:assert/strict';
-import {
-  mkdtempSync,
-  mkdirSync,
-  existsSync,
-  readFileSync,
-  writeFileSync,
-} from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { test } from 'node:test';
-import { openTaskStore, STATUS } from '../task-store.mjs';
-
-// A temp project with a .git marker, so the store anchors its .ai/tasks/ there.
-function makeProject() {
-  const project = mkdtempSync(join(tmpdir(), 'task-store-'));
-  mkdirSync(join(project, '.git'));
-  return project;
-}
-
-function sampleTask(id) {
-  return {
-    id,
-    title: `task ${id}`,
-    description: 'desc',
-    status: STATUS.OPEN,
-    size: 'trivial',
-    createdAt: new Date().toISOString(),
-    messages: [],
-  };
-}
-
-test('openTaskStore anchors at the nearest project marker (.ai/ counts, not only .git)', () => {
-  // A project rooted only by .ai/ (no .git) must still resolve — the repo-less case.
-  const project = mkdtempSync(join(tmpdir(), 'ai-only-'));
-  mkdirSync(join(project, '.ai'));
-  const nested = join(project, 'src', 'deep');
-  mkdirSync(nested, { recursive: true });
-  const store = openTaskStore(nested);
-  assert.ok(
-    store,
-    'store resolves from a nested dir under an .ai/-rooted project',
-  );
-  assert.equal(store.root, project);
-});
-
-test('add and active: a new task shows up in active', () => {
-  const store = openTaskStore(makeProject());
-  store.add(sampleTask('t1'));
-  const active = store.active();
-  assert.equal(active.length, 1);
-  assert.equal(active[0].id, 't1');
-  assert.deepEqual(store.history(), []);
-});
-
-test('update merges fields into the active task', () => {
-  const store = openTaskStore(makeProject());
-  store.add(sampleTask('t1'));
-  store.update('t1', { status: STATUS.BLOCKED, note: 'waiting' });
-  const task = store.active()[0];
-  assert.equal(task.status, STATUS.BLOCKED);
-  assert.equal(task.note, 'waiting');
-  assert.equal(store.update('missing', {}), null);
-});
-
-test('close MOVES a task from active to history, never deletes', () => {
-  const store = openTaskStore(makeProject());
-  store.add(sampleTask('t1'));
-  store.add(sampleTask('t2'));
-
-  const { task: closed } = store.close('t1', STATUS.DONE, {
-    reason: 'finished',
-    evidence: 'npm test -> 12 passing',
-  });
-  assert.equal(closed.status, STATUS.DONE);
-  assert.equal(closed.closeReason, 'finished');
-  assert.equal(closed.evidence, 'npm test -> 12 passing');
-  assert.ok(closed.closedAt);
-
-  assert.deepEqual(
-    store.active().map((task) => task.id),
-    ['t2'],
-  );
-  assert.deepEqual(
-    store.history().map((task) => task.id),
-    ['t1'],
-  );
-});
-
-test('closing as done WITHOUT evidence is refused; the task stays active', () => {
-  const store = openTaskStore(makeProject());
-  store.add(sampleTask('t1'));
-  const result = store.close('t1', STATUS.DONE, { reason: 'trust me' });
-  assert.ok(result.error, 'done without evidence must return an error');
-  assert.match(result.error, /evidence/i);
-  assert.equal(store.active().length, 1, 'the task is not moved to history');
-});
-
-test('abandon is a terminal close: moves to history with reason, no evidence needed', () => {
-  const store = openTaskStore(makeProject());
-  store.add(sampleTask('t1'));
-  const { task } = store.close('t1', STATUS.ABANDONED, { reason: 'no longer needed' });
-  assert.equal(task.status, STATUS.ABANDONED);
-  assert.equal(store.active().length, 0);
-  assert.equal(store.history()[0].status, STATUS.ABANDONED);
-  assert.equal(store.history()[0].closeReason, 'no longer needed');
-});
-
-test('promoteToForge links a run and keeps the task active as in_forge', () => {
-  const store = openTaskStore(makeProject());
-  store.add(sampleTask('t1'));
-  const promoted = store.promoteToForge('t1', 'run-42');
-  assert.equal(promoted.status, STATUS.IN_FORGE);
-  assert.equal(promoted.forgeRunId, 'run-42');
-  assert.equal(store.active().length, 1, 'in_forge is still active, not closed');
-});
-
-test('close rejects a non-terminal status and an unknown id', () => {
-  const store = openTaskStore(makeProject());
-  store.add(sampleTask('t1'));
-  assert.ok(store.close('t1', STATUS.OPEN, { reason: 'x' }).error);
-  assert.ok(store.close('missing', STATUS.DONE, { evidence: 'x' }).error);
-  assert.equal(store.active().length, 1);
-});
-
-test('counter persists and reads back', () => {
-  const store = openTaskStore(makeProject());
-  assert.equal(store.counter(), 0);
-  store.setCounter(7);
-  assert.equal(store.counter(), 7);
-});
-
-test('history is append-only across multiple closes', () => {
-  const store = openTaskStore(makeProject());
-  store.add(sampleTask('t1'));
-  store.add(sampleTask('t2'));
-  store.close('t1', STATUS.DONE, { reason: 'a', evidence: 'tests green' });
-  store.close('t2', STATUS.ABANDONED, { reason: 'b' });
-  assert.deepEqual(
-    store.history().map((task) => task.id),
-    ['t1', 't2'],
-  );
-});
-
-test('a corrupt active.json is treated as empty, then healed by a write', () => {
-  const project = makeProject();
-  const store = openTaskStore(project);
-  mkdirSync(join(project, '.ai', 'tasks'), { recursive: true });
-  const path = join(project, '.ai', 'tasks', 'active.json');
-  writeFileSync(path, '{broken');
-  assert.deepEqual(store.active(), []);
-  store.add(sampleTask('t1'));
-  assert.ok(existsSync(path));
-  assert.equal(JSON.parse(readFileSync(path, 'utf8')).tasks.length, 1);
-});
-
-test('a UTF-8 BOM on active.json/counter.json does not make the store treat them as empty/corrupt', () => {
-  const project = makeProject();
-  const tasksDir = join(project, '.ai', 'tasks');
-  mkdirSync(tasksDir, { recursive: true });
-
-  const bom = '';
-  writeFileSync(
-    join(tasksDir, 'active.json'),
-    bom + JSON.stringify({ tasks: [sampleTask('t1')] }),
-  );
-  writeFileSync(join(tasksDir, 'counter.json'), bom + JSON.stringify({ count: 3 }));
-
-  const store = openTaskStore(project);
-  assert.deepEqual(
-    store.active().map((task) => task.id),
-    ['t1'],
-    'a BOM-prefixed active.json must still be read as its real content, not as empty',
-  );
-  assert.equal(
-    store.counter(),
-    3,
-    'a BOM-prefixed counter.json must still be read as its real value, not 0',
-  );
-});