@devrik-tools/claude-gates 0.1.2 → 0.2.0

package/.claude-plugin/marketplace.json

@@ -11,7 +11,13 @@
       "name": "gates",
       "source": "./plugins/gates",
       "description": "PreToolUse gates: destructive-command blocks, protected paths, delegation/spec/quality rules, tool-discovery and forge-pipeline enforcement. Which gates run is decided by .ai/config.json (project) or ~/.claude/claude-gates/config.json (global).",
-      "version": "0.1.0"
+      "version": "0.2.0"
+    },
+    {
+      "name": "tasks",
+      "source": "./plugins/tasks",
+      "description": "Deterministic task tracking: the model registers tasks via the CLI, a UserPromptSubmit hook reminds of open tasks every few messages, and a SessionStart hook lists active tasks when a session opens.",
+      "version": "0.2.0"
     }
   ]
 }

package/cli/__tests__/config.test.mjs

@@ -1,101 +1,113 @@
-import assert from 'node:assert/strict';
-import {
-  mkdtempSync,
-  mkdirSync,
-  writeFileSync,
-  readFileSync,
-  existsSync,
-} from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { test } from 'node:test';
-import {
-  SCOPES,
-  findProjectRoot,
-  configPathFor,
-  readConfig,
-  mergeConfig,
-  writeConfig,
-} from '../config.mjs';
-
-function temporaryDirectory() {
-  return mkdtempSync(join(tmpdir(), 'claude-gates-'));
-}
-
-test('findProjectRoot climbs to the .git directory and falls back to the start', () => {
-  const root = temporaryDirectory();
-  mkdirSync(join(root, '.git'));
-  const nested = join(root, 'src', 'deep');
-  mkdirSync(nested, { recursive: true });
-  assert.equal(findProjectRoot(nested), root);
-
-  const loose = temporaryDirectory();
-  assert.equal(findProjectRoot(loose), loose);
-});
-
-test('findProjectRoot never climbs into the home directory', () => {
-  const fakeHome = temporaryDirectory();
-  mkdirSync(join(fakeHome, '.ai'));
-  const project = join(fakeHome, 'repos', 'app');
-  mkdirSync(project, { recursive: true });
-  assert.equal(findProjectRoot(project, { home: fakeHome }), project);
-});
-
-test('configPathFor resolves both scopes', () => {
-  const home = temporaryDirectory();
-  const project = temporaryDirectory();
-  mkdirSync(join(project, '.ai'));
-  assert.equal(
-    configPathFor(SCOPES.GLOBAL, { home }),
-    join(home, '.claude', 'claude-gates', 'config.json'),
-  );
-  assert.equal(
-    configPathFor(SCOPES.PROJECT, { cwd: project }),
-    join(project, '.ai', 'config.json'),
-  );
-  assert.throws(() => configPathFor('nope'), /Unknown scope/);
-});
-
-test('readConfig distinguishes missing, valid and corrupt', () => {
-  const directory = temporaryDirectory();
-  const path = join(directory, 'config.json');
-  assert.deepEqual(readConfig(path), {
-    exists: false,
-    data: {},
-    corrupt: false,
-  });
-  writeFileSync(path, '{"autoCommit":true}');
-  assert.deepEqual(readConfig(path), {
-    exists: true,
-    data: { autoCommit: true },
-    corrupt: false,
-  });
-  writeFileSync(path, '{nope');
-  assert.equal(readConfig(path).corrupt, true);
-});
-
-test('mergeConfig keeps unrelated keys and unknown gates, overrides known ones', () => {
-  const existing = {
-    autoCommit: true,
-    gates: { oldGate: true, blockX: false },
-  };
-  const merged = mergeConfig(existing, {
-    adopted: 'partial',
-    gates: { blockX: true, blockY: false },
-    gateVersion: '3.0.0',
-  });
-  assert.deepEqual(merged, {
-    autoCommit: true,
-    adopted: 'partial',
-    gateVersion: '3.0.0',
-    gates: { oldGate: true, blockX: true, blockY: false },
-  });
-});
-
-test('writeConfig creates parent folders and writes pretty JSON with trailing newline', () => {
-  const directory = temporaryDirectory();
-  const path = join(directory, 'a', 'b', 'config.json');
-  writeConfig(path, { adopted: true });
-  assert.ok(existsSync(path));
-  assert.equal(readFileSync(path, 'utf8'), '{\n  "adopted": true\n}\n');
-});
+import assert from 'node:assert/strict';
+import {
+  mkdtempSync,
+  mkdirSync,
+  writeFileSync,
+  readFileSync,
+  existsSync,
+} from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { test } from 'node:test';
+import {
+  SCOPES,
+  findProjectRoot,
+  configPathFor,
+  readConfig,
+  mergeConfig,
+  writeConfig,
+} from '../config.mjs';
+
+function temporaryDirectory() {
+  return mkdtempSync(join(tmpdir(), 'claude-gates-'));
+}
+
+test('findProjectRoot climbs to the .git directory and falls back to the start', () => {
+  const root = temporaryDirectory();
+  mkdirSync(join(root, '.git'));
+  const nested = join(root, 'src', 'deep');
+  mkdirSync(nested, { recursive: true });
+  assert.equal(findProjectRoot(nested), root);
+
+  const loose = temporaryDirectory();
+  assert.equal(findProjectRoot(loose), loose);
+});
+
+test('findProjectRoot never climbs into the home directory', () => {
+  const fakeHome = temporaryDirectory();
+  mkdirSync(join(fakeHome, '.ai'));
+  const project = join(fakeHome, 'repos', 'app');
+  mkdirSync(project, { recursive: true });
+  assert.equal(findProjectRoot(project, { home: fakeHome }), project);
+});
+
+test('configPathFor resolves both scopes', () => {
+  const home = temporaryDirectory();
+  const project = temporaryDirectory();
+  mkdirSync(join(project, '.ai'));
+  assert.equal(
+    configPathFor(SCOPES.GLOBAL, { home }),
+    join(home, '.claude', 'claude-gates', 'config.json'),
+  );
+  assert.equal(
+    configPathFor(SCOPES.PROJECT, { cwd: project }),
+    join(project, '.ai', 'config.json'),
+  );
+  assert.throws(() => configPathFor('nope'), /Unknown scope/);
+});
+
+test('readConfig distinguishes missing, valid and corrupt', () => {
+  const directory = temporaryDirectory();
+  const path = join(directory, 'config.json');
+  assert.deepEqual(readConfig(path), {
+    exists: false,
+    data: {},
+    corrupt: false,
+  });
+  writeFileSync(path, '{"autoCommit":true}');
+  assert.deepEqual(readConfig(path), {
+    exists: true,
+    data: { autoCommit: true },
+    corrupt: false,
+  });
+  writeFileSync(path, '{nope');
+  assert.equal(readConfig(path).corrupt, true);
+});
+
+test('readConfig strips a leading UTF-8 BOM instead of treating the file as corrupt', () => {
+  const directory = temporaryDirectory();
+  const path = join(directory, 'config.json');
+  const bom = '';
+  writeFileSync(path, bom + '{"autoCommit":true}');
+  assert.deepEqual(readConfig(path), {
+    exists: true,
+    data: { autoCommit: true },
+    corrupt: false,
+  });
+});
+
+test('mergeConfig keeps unrelated keys and unknown gates, overrides known ones', () => {
+  const existing = {
+    autoCommit: true,
+    gates: { oldGate: true, blockX: false },
+  };
+  const merged = mergeConfig(existing, {
+    adopted: 'partial',
+    gates: { blockX: true, blockY: false },
+    gateVersion: '3.0.0',
+  });
+  assert.deepEqual(merged, {
+    autoCommit: true,
+    adopted: 'partial',
+    gateVersion: '3.0.0',
+    gates: { oldGate: true, blockX: true, blockY: false },
+  });
+});
+
+test('writeConfig creates parent folders and writes pretty JSON with trailing newline', () => {
+  const directory = temporaryDirectory();
+  const path = join(directory, 'a', 'b', 'config.json');
+  writeConfig(path, { adopted: true });
+  assert.ok(existsSync(path));
+  assert.equal(readFileSync(path, 'utf8'), '{\n  "adopted": true\n}\n');
+});

package/cli/__tests__/install.test.mjs

@@ -0,0 +1,102 @@
+// installPlugin used to install only the marketplace's FIRST plugin (`const [plugin] =
+// manifest.plugins`), so a second plugin (like `tasks`) never got installed by `init`. These
+// tests exercise the fixed multi-plugin behavior with a fake `runClaude` — never the real
+// `claude` binary, which would actually install plugins on the machine running the test.
+
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { SCOPES } from '../config.mjs';
+import { installPlugin, pluginInstallCommands } from '../install.mjs';
+import { REPOSITORY_ROOT } from '../constants.mjs';
+
+test('pluginInstallCommands lists one command per plugin the marketplace declares (gates AND tasks)', () => {
+  const commands = pluginInstallCommands();
+  assert.ok(
+    commands.some((command) => command.includes('install gates@')),
+    'gates must still be installable',
+  );
+  assert.ok(
+    commands.some((command) => command.includes('install tasks@')),
+    'tasks must now be installable too — this was the whole point of the fix',
+  );
+});
+
+test('installPlugin installs EVERY plugin, not just the first', () => {
+  const invocations = [];
+  const runClaude = (args) => {
+    invocations.push(args);
+    return '';
+  };
+
+  const result = installPlugin(SCOPES.PROJECT, { cwd: REPOSITORY_ROOT, runClaude });
+
+  assert.equal(result.installed, true);
+  const installedPlugins = result.results.map((entry) => entry.plugin);
+  assert.ok(installedPlugins.includes('gates'));
+  assert.ok(installedPlugins.includes('tasks'));
+  assert.equal(result.results.every((entry) => entry.installed), true);
+
+  // One marketplace add + one install call per plugin.
+  const installCalls = invocations.filter((args) => args[1] === 'install');
+  assert.equal(installCalls.length, result.results.length);
+});
+
+test('installPlugin: one plugin failing does not stop the rest from being attempted', () => {
+  const runClaude = (args) => {
+    if (args[0] === 'plugin' && args[1] === 'install' && args[2].startsWith('gates@')) {
+      throw new Error('boom: gates install failed');
+    }
+    return '';
+  };
+
+  const result = installPlugin(SCOPES.GLOBAL, { cwd: REPOSITORY_ROOT, runClaude });
+
+  assert.equal(result.installed, false, 'overall result reflects the partial failure');
+  const gatesEntry = result.results.find((entry) => entry.plugin === 'gates');
+  const tasksEntry = result.results.find((entry) => entry.plugin === 'tasks');
+  assert.equal(gatesEntry.installed, false);
+  assert.match(gatesEntry.reason, /boom/);
+  assert.equal(
+    tasksEntry.installed,
+    true,
+    'tasks must still install even though gates failed',
+  );
+  assert.match(result.reason, /gates/);
+});
+
+test('installPlugin uses the marketplace name Claude Code actually registered, not the manifest name', () => {
+  // The repo's manifest name is `claude-gates`, but if the user added this same directory
+  // earlier under a different name, Claude Code keeps that name. installPlugin must install as
+  // plugin@<registered-name>, or `claude` answers "not found in marketplace claude-gates".
+  const installCalls = [];
+  const runClaude = (args) => {
+    if (args[1] === 'marketplace' && args[2] === 'list') {
+      // A listing where THIS repo is registered under the name `devrik`.
+      return `Configured marketplaces:\n\n  ❯ devrik\n    Source: Directory (${REPOSITORY_ROOT})\n`;
+    }
+    if (args[1] === 'install') installCalls.push(args[2]);
+    return '';
+  };
+
+  const result = installPlugin(SCOPES.GLOBAL, { cwd: REPOSITORY_ROOT, runClaude });
+
+  assert.equal(result.installed, true);
+  assert.ok(
+    installCalls.every((target) => target.endsWith('@devrik')),
+    `every install must target @devrik, got: ${installCalls.join(', ')}`,
+  );
+});
+
+test('installPlugin degrades gracefully when the claude binary is entirely unreachable', () => {
+  const runClaude = () => {
+    const error = new Error('spawn claude ENOENT');
+    error.code = 'ENOENT';
+    throw error;
+  };
+
+  const result = installPlugin(SCOPES.PROJECT, { cwd: REPOSITORY_ROOT, runClaude });
+
+  assert.equal(result.installed, false);
+  assert.ok(result.results.every((entry) => !entry.installed));
+  assert.ok(result.results.every((entry) => /not found on PATH/.test(entry.reason)));
+});

package/cli/__tests__/materialize.test.mjs

@@ -0,0 +1,95 @@
+// materializeGates only computes the NEW selection's map; how much of an existing gate
+// entry survives depends on the run's mode. This test exercises that combination the same
+// way init.mjs does — a bug here reads as "materialize wiped my config" even though
+// materializeGates and mergeConfig are individually simple.
+
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+import { mergeConfig } from '../config.mjs';
+import { materializeGates } from '../materialize.mjs';
+import { loadRegistry, allGates } from '../registry.mjs';
+import { resolveSelection, MODES } from '../selection.mjs';
+
+const registry = loadRegistry();
+const gates = allGates(registry);
+const paramGate = gates.find(
+  (gate) => Array.isArray(gate.params) && gate.params.length > 0,
+);
+
+function mergedGatesAfter(mode, existingGates) {
+  const existing = {
+    adopted: 'partial',
+    gateVersion: registry.gateVersion,
+    gates: existingGates,
+  };
+  const selection = resolveSelection(registry, mode, {
+    gates: [paramGate.id],
+    families: [paramGate.family],
+  });
+  const materialized = materializeGates(registry, selection, existing.gates, mode);
+  return mergeConfig(existing, {
+    adopted: 'partial',
+    gates: materialized,
+    gateVersion: registry.gateVersion,
+  }).gates;
+}
+
+test('registry has at least one gate with params, for these tests to exercise', () => {
+  assert.ok(paramGate, 'registry must have at least one gate with params');
+});
+
+test('DEFAULTS re-run preserves a gate the user already disabled, with its custom params, untouched', () => {
+  const merged = mergedGatesAfter(MODES.DEFAULTS, {
+    [paramGate.configKey]: { enabled: false, __userTuned: 'kept-value' },
+  });
+
+  assert.equal(
+    merged[paramGate.configKey].enabled,
+    false,
+    'a gate the user disabled must stay disabled after a defaults re-run',
+  );
+  assert.equal(
+    merged[paramGate.configKey].__userTuned,
+    'kept-value',
+    "the user's own param edit must not be replaced by the gate's built-in default",
+  );
+
+  const untouched = gates.find((gate) => gate.configKey !== paramGate.configKey);
+  assert.ok(
+    Object.prototype.hasOwnProperty.call(merged, untouched.configKey),
+    'a gate absent from the existing config must still appear after materializing',
+  );
+});
+
+test('an explicit GRANULAR pick overrides a previously disabled gate: the named choice wins', () => {
+  const merged = mergedGatesAfter(MODES.GRANULAR, {
+    [paramGate.configKey]: { enabled: false, __userTuned: 'kept-value' },
+  });
+
+  assert.equal(
+    merged[paramGate.configKey].enabled,
+    true,
+    'naming a gate in --gates must re-enable it even if the config had it disabled',
+  );
+});
+
+test('an explicit GRANULAR pick still preserves the user\'s own params (no new values were passed)', () => {
+  const merged = mergedGatesAfter(MODES.GRANULAR, {
+    [paramGate.configKey]: { enabled: false, __userTuned: 'kept-value' },
+  });
+
+  assert.equal(
+    merged[paramGate.configKey].__userTuned,
+    'kept-value',
+    'params the user tuned by hand survive an explicit pick that only changes enabled',
+  );
+});
+
+test('FAMILIES mode behaves the same as GRANULAR for an already-configured gate', () => {
+  const merged = mergedGatesAfter(MODES.FAMILIES, {
+    [paramGate.configKey]: { enabled: false, __userTuned: 'kept-value' },
+  });
+
+  assert.equal(merged[paramGate.configKey].enabled, true);
+  assert.equal(merged[paramGate.configKey].__userTuned, 'kept-value');
+});

package/cli/__tests__/registry-gates-consistency.test.mjs

@@ -1,44 +1,52 @@
-// The registry and the gates on disk must agree: every PreToolUse gate the registry
-// declares has to have a script, and every gate folder on disk has to be declared. A
-// mismatch (a registry entry with no file, like the old `autocommit`, or an orphan folder)
-// is what made `init` spawn a non-existent gate — this test blocks it from returning.
-
-import assert from 'node:assert/strict';
-import { existsSync, readdirSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-import { test } from 'node:test';
-import { fileURLToPath } from 'node:url';
-import { loadRegistry, allGates } from '../registry.mjs';
-
-const REPO = join(dirname(fileURLToPath(import.meta.url)), '..', '..');
-const GATES_DIR = join(REPO, 'plugins', 'gates', 'hooks', 'gates');
-
-const registry = loadRegistry();
-const preToolUseGates = allGates(registry).filter(
-  (gate) => gate.event === 'PreToolUse',
-);
-
-test('every PreToolUse gate in the registry has its script on disk', () => {
-  for (const gate of preToolUseGates) {
-    const scriptPath = join(REPO, 'plugins', 'gates', 'hooks', gate.script);
-    assert.ok(
-      existsSync(scriptPath),
-      `registry declares gate "${gate.id}" (script ${gate.script}) but the file is missing`,
-    );
-  }
-});
-
-test('every gate folder on disk is declared in the registry', () => {
-  const declaredScripts = new Set(preToolUseGates.map((gate) => gate.script));
-  const folders = readdirSync(GATES_DIR, { withFileTypes: true })
-    .filter((entry) => entry.isDirectory())
-    .map((entry) => entry.name);
-
-  for (const folder of folders) {
-    const expectedScript = `gates/${folder}/index.mjs`;
-    assert.ok(
-      declaredScripts.has(expectedScript),
-      `gate folder "${folder}" exists on disk but no registry entry points to ${expectedScript}`,
-    );
-  }
-});
+// The registry and the gates on disk must agree: every PreToolUse gate the registry
+// declares has to have a script, and every gate folder on disk has to be declared. A
+// mismatch (a registry entry with no file, like the old `autocommit`, or an orphan folder)
+// is what made `init` spawn a non-existent gate — this test blocks it from returning.
+
+import assert from 'node:assert/strict';
+import { existsSync, readdirSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { test } from 'node:test';
+import { fileURLToPath } from 'node:url';
+import { loadRegistry, allGates } from '../registry.mjs';
+
+const REPO = join(dirname(fileURLToPath(import.meta.url)), '..', '..');
+const GATES_DIR = join(REPO, 'plugins', 'gates', 'hooks', 'gates');
+
+const registry = loadRegistry();
+const preToolUseGates = allGates(registry).filter(
+  (gate) => gate.event === 'PreToolUse',
+);
+// Gates that live one-per-folder under plugins/gates/hooks/gates/ — regardless of which
+// event they hook (most are PreToolUse, but e.g. stop-pending is Stop). Session-scoped
+// hooks (doctor.mjs, ask-adoption.mjs, ...) are top-level scripts outside this folder and
+// are intentionally excluded, matching the `gates/x.mjs` vs `x.mjs` convention documented
+// in registry.mjs's SCRIPT_PATTERN.
+const folderGates = allGates(registry).filter((gate) =>
+  gate.script.startsWith('gates/'),
+);
+
+test('every PreToolUse gate in the registry has its script on disk', () => {
+  for (const gate of preToolUseGates) {
+    const scriptPath = join(REPO, 'plugins', 'gates', 'hooks', gate.script);
+    assert.ok(
+      existsSync(scriptPath),
+      `registry declares gate "${gate.id}" (script ${gate.script}) but the file is missing`,
+    );
+  }
+});
+
+test('every gate folder on disk is declared in the registry', () => {
+  const declaredScripts = new Set(folderGates.map((gate) => gate.script));
+  const folders = readdirSync(GATES_DIR, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => entry.name);
+
+  for (const folder of folders) {
+    const expectedScript = `gates/${folder}/index.mjs`;
+    assert.ok(
+      declaredScripts.has(expectedScript),
+      `gate folder "${folder}" exists on disk but no registry entry points to ${expectedScript}`,
+    );
+  }
+});

package/cli/__tests__/task.test.mjs

@@ -0,0 +1,124 @@
+// 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');
+});