@bonesofspring/ai-rules 0.2.26 → 0.2.27

package/scripts/test-chain-team-phases-coverage.mjs

@@ -515,4 +515,179 @@ for (const hook of hooks) {
   }
 }
 
-console.log(`Verified openspec-author handoff, qa-tester handoff, pipeline misparse blocking, legacy fallback, writeStatus durability, and stale attemptId rejection in ${hooks.length} hooks.`);
+// ---------------------------------------------------------------------------
+// Test 7 — end_human_gate idempotency (H2): a second/retried end_human_gate
+// must be a no-op. It must not activate the step after the one already resumed.
+// ---------------------------------------------------------------------------
+for (const hook of hooks) {
+  const root = fs.mkdtempSync(path.join(packageDirectory, '.gate-idempotent-'));
+  try {
+    const platform = platformFor(hook);
+    const runId = 'gate-idempotent-run';
+    const { taskDirectory } = writeTask(
+      root,
+      hook,
+      'gate-idempotent',
+      {
+        intent: 'feature',
+        profile: 'standard',
+        steps: [
+          { agent: 'task-analyst', label: 'Analyze' },
+          { agent: 'feature-developer', label: 'Develop' },
+          { agent: 'build-verifier', label: 'Verify' },
+        ],
+        humanGates: ['after:task-analyst'],
+      },
+      {
+        slug: 'gate-idempotent',
+        intent: 'feature',
+        pipelineIndex: 0,
+        currentAgent: 'task-analyst',
+        phase: 'human_gate',
+        state: 'awaiting_approval',
+        awaitingHumanGate: true,
+        activeHumanGateEventId: `${runId}:gate`,
+        activeAttempts: {},
+        metricsRunId: runId,
+      },
+      {
+        schemaVersion: 1,
+        task: { runId, slug: 'gate-idempotent', preset: 'ai-rules', stack: 'test', platform, intent: 'feature', profile: 'standard' },
+        events: [{ eventId: `${runId}:task_started`, type: 'task_started', at: todayIso }],
+      },
+    );
+    invokeHook(hook, root, undefined, { action: 'end_human_gate', activateNext: true });
+    const afterFirst = readJson(path.join(taskDirectory, 'status.json'));
+    assert.equal(afterFirst.pipelineIndex, 1, `${hook}: end_human_gate did not resume the next step`);
+    assert.equal(afterFirst.currentAgent, 'feature-developer', `${hook}: end_human_gate resumed the wrong agent`);
+    // Duplicate call: no open gate anymore, so it must not advance again.
+    invokeHook(hook, root, undefined, { action: 'end_human_gate', activateNext: true });
+    const afterSecond = readJson(path.join(taskDirectory, 'status.json'));
+    assert.equal(afterSecond.pipelineIndex, 1, `${hook}: duplicate end_human_gate skipped a pipeline step`);
+    assert.equal(afterSecond.currentAgent, 'feature-developer', `${hook}: duplicate end_human_gate changed the active agent`);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Test 8 — terminal human gate (H3): closing a gate that follows the final
+// step must complete the pipeline, not leave it in_progress forever.
+// ---------------------------------------------------------------------------
+for (const hook of hooks) {
+  const root = fs.mkdtempSync(path.join(packageDirectory, '.gate-terminal-'));
+  try {
+    const platform = platformFor(hook);
+    const runId = 'gate-terminal-run';
+    const { taskDirectory } = writeTask(
+      root,
+      hook,
+      'gate-terminal',
+      {
+        intent: 'feature',
+        profile: 'standard',
+        steps: [
+          { agent: 'task-analyst', label: 'Analyze' },
+          { agent: 'feature-developer', label: 'Develop' },
+        ],
+        humanGates: ['after:feature-developer'],
+      },
+      {
+        slug: 'gate-terminal',
+        intent: 'feature',
+        pipelineIndex: 1,
+        currentAgent: 'feature-developer',
+        phase: 'human_gate',
+        state: 'awaiting_approval',
+        awaitingHumanGate: true,
+        activeHumanGateEventId: `${runId}:gate`,
+        activeAttempts: {},
+        metricsRunId: runId,
+      },
+      {
+        schemaVersion: 1,
+        task: { runId, slug: 'gate-terminal', preset: 'ai-rules', stack: 'test', platform, intent: 'feature', profile: 'standard' },
+        events: [{ eventId: `${runId}:task_started`, type: 'task_started', at: todayIso }],
+      },
+    );
+    invokeHook(hook, root, undefined, { action: 'end_human_gate', activateNext: true });
+    const status = readJson(path.join(taskDirectory, 'status.json'));
+    assert.equal(status.state, 'completed', `${hook}: terminal gate did not complete the pipeline (got: ${status.state})`);
+    assert.equal(status.phase, 'done', `${hook}: terminal gate did not reach phase=done`);
+    const completed = readJson(path.join(taskDirectory, 'metrics.json')).events.filter(
+      (event) => event.type === 'task_completed',
+    );
+    assert.equal(completed.length, 1, `${hook}: terminal gate did not emit task_completed`);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Test 9 — stale lock recovery (H4): a lock file left by a killed process
+// (mtime far in the past) must be reclaimed instead of failing the hook.
+// ---------------------------------------------------------------------------
+for (const hook of hooks) {
+  const root = fs.mkdtempSync(path.join(packageDirectory, '.stale-lock-'));
+  try {
+    const platform = platformFor(hook);
+    const runId = 'stale-lock-run';
+    const attemptId = `${runId}:step-0:feature-developer:attempt-1`;
+    const { taskDirectory } = writeTask(
+      root,
+      hook,
+      'stale-lock',
+      { intent: 'feature', steps: [{ agent: 'feature-developer' }] },
+      {
+        slug: 'stale-lock',
+        intent: 'feature',
+        pipelineIndex: 0,
+        currentAgent: 'feature-developer',
+        phase: 'executing',
+        state: 'completed',
+        activeAttempts: {
+          [attemptId]: { agent: 'feature-developer', stepIndex: 0, attempt: 1, startedAt: todayIso, parallelGroupId: null },
+        },
+        metricsRunId: runId,
+      },
+      {
+        schemaVersion: 1,
+        task: { runId, slug: 'stale-lock', preset: 'ai-rules', stack: 'test', platform, intent: 'feature', profile: 'standard' },
+        events: [
+          { eventId: `${runId}:task_started`, type: 'task_started', at: todayIso },
+          { eventId: `${runId}:start`, type: 'attempt_started', attemptId, agent: 'feature-developer', stepIndex: 0, attempt: 1, at: todayIso },
+        ],
+      },
+    );
+    const lockPath = path.join(taskDirectory, 'metrics.json.lock');
+    fs.writeFileSync(lockPath, '');
+    const ancient = Date.now() / 1000 - 3600;
+    fs.utimesSync(lockPath, ancient, ancient);
+    const raw = invokeHook(hook, root, attemptId);
+    assert.ok(raw.length > 0, `${hook}: stale lock was not reclaimed (no output)`);
+    assert.equal(fs.existsSync(lockPath), false, `${hook}: stale lock was not cleaned up`);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Test 10 — slug traversal (H6): a slug escaping tasks/ must be rejected
+// without writing status.json outside the task tree.
+// ---------------------------------------------------------------------------
+for (const hook of hooks) {
+  const root = fs.mkdtempSync(path.join(packageDirectory, '.slug-traversal-'));
+  try {
+    const teamRoot = path.join(root, '.ai.local', 'team');
+    fs.mkdirSync(teamRoot, { recursive: true });
+    writeJson(path.join(teamRoot, 'active-task.json'), { slug: '../../evil' });
+    const raw = invokeHook(hook, root, undefined, {});
+    assert.deepEqual(JSON.parse(raw), {}, `${hook}: traversal slug was not rejected`);
+    assert.equal(fs.existsSync(path.join(root, '.ai.local', 'evil')), false, `${hook}: traversal slug wrote outside tasks/`);
+    assert.equal(fs.existsSync(path.join(root, 'evil')), false, `${hook}: traversal slug escaped the repo`);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+}
+
+console.log(`Verified openspec-author handoff, qa-tester handoff, pipeline misparse blocking, legacy fallback, writeStatus durability, stale attemptId rejection, end_human_gate idempotency, terminal-gate completion, stale-lock recovery, and slug-traversal rejection in ${hooks.length} hooks.`);

package/scripts/test-cli-init-clean.mjs

@@ -58,9 +58,15 @@ function assertGolden(tool, preset) {
     runInit(cli, tmp, tool, preset);
     const expected = readJson(path.join(goldenRoot, tool, `${preset}.json`));
     const actual = snapshotInstall(tmp);
-    if (tool === 'mavis') {
-      delete actual['.mavis/.ai-rules-install.json'];
-      delete expected.files['.mavis/.ai-rules-install.json'];
+    const manifestKey = {
+      cursor: '.cursor/.ai-rules-install.json',
+      claude: '.claude/.ai-rules-install.json',
+      mavis: '.mavis/.ai-rules-install.json',
+      opencode: '.opencode/.ai-rules-install.json',
+    }[tool];
+    if (manifestKey) {
+      delete actual[manifestKey];
+      delete expected.files[manifestKey];
     }
     assert.deepEqual(actual, expected.files, `${tool}/${preset} golden drifted`);
   } finally {
@@ -226,18 +232,13 @@ runInit(cli, mavisGoldenDir, 'mavis', 'next');
 const mavisFiles = snapshotInstall(mavisGoldenDir);
 delete mavisFiles['.mavis/.ai-rules-install.json'];
 const mavisGoldenPath = path.join(goldenRoot, 'mavis', 'next.json');
-if (!fs.existsSync(mavisGoldenPath)) {
-  writeJson(mavisGoldenPath, {
-    schemaVersion: 1,
-    tool: 'mavis',
-    preset: 'next',
-    files: mavisFiles,
-  });
-} else {
-  const expectedMavis = readJson(mavisGoldenPath);
-  delete expectedMavis.files['.mavis/.ai-rules-install.json'];
-  assert.deepEqual(mavisFiles, expectedMavis.files, 'mavis/next golden drifted');
-}
+assert.ok(
+  fs.existsSync(mavisGoldenPath),
+  'mavis/next golden missing — capture it with scripts/capture-cli-golden.mjs',
+);
+const expectedMavis = readJson(mavisGoldenPath);
+delete expectedMavis.files['.mavis/.ai-rules-install.json'];
+assert.deepEqual(mavisFiles, expectedMavis.files, 'mavis/next golden drifted');
 
 const ocFresh = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-opencode-fresh-'));
 const ocInitOut = execFileSync(
@@ -331,18 +332,13 @@ runInit(cli, ocGoldenDir, 'opencode', 'next');
 const ocFiles = snapshotInstall(ocGoldenDir);
 delete ocFiles['.opencode/.ai-rules-install.json'];
 const ocGoldenPath = path.join(goldenRoot, 'opencode', 'next.json');
-if (!fs.existsSync(ocGoldenPath)) {
-  writeJson(ocGoldenPath, {
-    schemaVersion: 1,
-    tool: 'opencode',
-    preset: 'next',
-    files: ocFiles,
-  });
-} else {
-  const expectedOc = readJson(ocGoldenPath);
-  delete expectedOc.files['.opencode/.ai-rules-install.json'];
-  assert.deepEqual(ocFiles, expectedOc.files, 'opencode/next golden drifted');
-}
+assert.ok(
+  fs.existsSync(ocGoldenPath),
+  'opencode/next golden missing — capture it with scripts/capture-cli-golden.mjs',
+);
+const expectedOc = readJson(ocGoldenPath);
+delete expectedOc.files['.opencode/.ai-rules-install.json'];
+assert.deepEqual(ocFiles, expectedOc.files, 'opencode/next golden drifted');
 
 const canonicalRepoAgents = fs.readFileSync(
   path.join(packageDirectory, 'presets', 'cursor', 'next', 'REPO_AGENTS.md'),
@@ -363,13 +359,13 @@ function ensureGolden(tool, preset, manifestRel) {
     const files = snapshotInstall(tmp);
     delete files[manifestRel];
     const goldenPath = path.join(goldenRoot, tool, `${preset}.json`);
-    if (!fs.existsSync(goldenPath)) {
-      writeJson(goldenPath, { schemaVersion: 1, tool, preset, files });
-    } else {
-      const expected = readJson(goldenPath);
-      delete expected.files[manifestRel];
-      assert.deepEqual(files, expected.files, `${tool}/${preset} golden drifted`);
-    }
+    assert.ok(
+      fs.existsSync(goldenPath),
+      `${tool}/${preset} golden missing — capture it with scripts/capture-cli-golden.mjs`,
+    );
+    const expected = readJson(goldenPath);
+    delete expected.files[manifestRel];
+    assert.deepEqual(files, expected.files, `${tool}/${preset} golden drifted`);
   } finally {
     fs.rmSync(tmp, { recursive: true, force: true });
   }
@@ -618,6 +614,130 @@ assert.equal(
   'migration must not write the pointer README outside --cwd',
 );
 
+// --- CLI ownership + path-safety regressions ----------------------------
+// init writes an ownership manifest for cursor/claude (like mavis/opencode).
+const ownedClean = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-owned-clean-'));
+runInit(cli, ownedClean, 'cursor', 'next');
+const cursorManifest = readJson(path.join(ownedClean, '.cursor', '.ai-rules-install.json'));
+assert.equal(cursorManifest.platform, 'cursor');
+assert.ok(cursorManifest.managedFiles['.cursor/rules/next-app-core.mdc']);
+assert.ok(cursorManifest.managedFiles['AGENTS.md']);
+assert.ok(cursorManifest.shippedMcpServerIds.includes('context7'));
+
+// A consumer file under .cursor/ and a modified shared AGENTS.md survive clean.
+fs.writeFileSync(path.join(ownedClean, '.cursor', 'rules', 'mine.mdc'), '# mine\n');
+fs.writeFileSync(path.join(ownedClean, 'AGENTS.md'), '# consumer agents\n');
+runClean(ownedClean, 'cursor');
+assert.equal(
+  fs.existsSync(path.join(ownedClean, '.cursor', 'rules', 'mine.mdc')),
+  true,
+  'consumer rule must survive clean cursor',
+);
+assert.equal(
+  fs.readFileSync(path.join(ownedClean, 'AGENTS.md'), 'utf8'),
+  '# consumer agents\n',
+  'modified shared AGENTS.md must survive clean cursor',
+);
+
+// clean without an install manifest is fail-safe: it deletes nothing.
+const noManifest = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-no-manifest-'));
+fs.mkdirSync(path.join(noManifest, '.cursor', 'rules'), { recursive: true });
+fs.writeFileSync(path.join(noManifest, '.cursor', 'rules', 'mine.mdc'), '# mine\n');
+const noManifestClean = runCli(noManifest, ['clean', 'cursor']);
+assert.equal(noManifestClean.status, 1);
+assert.equal(
+  fs.existsSync(path.join(noManifest, '.cursor', 'rules', 'mine.mdc')),
+  true,
+  'clean cursor must not delete consumer files when no manifest exists',
+);
+
+// A manifest entry that escapes cwd is ignored, never followed.
+const traversal = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-traversal-'));
+fs.writeFileSync(path.join(traversal, 'victim.txt'), 'victim\n');
+const victimHash = sha256File(path.join(traversal, 'victim.txt'));
+fs.mkdirSync(path.join(traversal, '.mavis'), { recursive: true });
+fs.writeFileSync(
+  path.join(traversal, '.mavis', '.ai-rules-install.json'),
+  `${JSON.stringify({
+    schemaVersion: 1,
+    platform: 'mavis',
+    preset: 'next',
+    managedFiles: { '../victim.txt': victimHash },
+    managedDirectories: ['../'],
+  })}\n`,
+);
+const traversalClean = runCli(traversal, ['clean', 'mavis']);
+assert.equal(traversalClean.status, 0);
+assert.equal(
+  fs.existsSync(path.join(traversal, 'victim.txt')),
+  true,
+  'path-traversal manifest entry must not delete outside cwd',
+);
+
+// A symlinked destination root is refused instead of written through.
+const symlinkInit = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-symlink-init-'));
+const symlinkTarget = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-symlink-target-'));
+fs.symlinkSync(symlinkTarget, path.join(symlinkInit, '.ai.local'), 'dir');
+const symlinkResult = runCli(symlinkInit, ['init', 'cursor', '--preset', 'next']);
+assert.equal(symlinkResult.status, 1);
+assert.equal(
+  fs.existsSync(path.join(symlinkTarget, 'team')),
+  false,
+  'init must not write .ai.local/team through a symlinked .ai.local',
+);
+const mavisLink = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-mavis-link-'));
+const mavisTarget = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-mavis-link-target-'));
+fs.symlinkSync(mavisTarget, path.join(mavisLink, '.mavis'), 'dir');
+const mavisLinkResult = runCli(mavisLink, ['init', 'mavis', '--preset', 'next']);
+assert.equal(mavisLinkResult.status, 1);
+assert.equal(
+  fs.existsSync(path.join(mavisTarget, 'AGENTS.md')),
+  false,
+  'init mavis must not write through a symlinked .mavis',
+);
+
+// A failed re-init must not roll back pre-existing consumer directories.
+const rollbackReinit = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-rollback-reinit-'));
+runInit(cli, rollbackReinit, 'cursor', 'next');
+fs.writeFileSync(path.join(rollbackReinit, '.cursor', 'rules', 'mine.mdc'), '# mine\n');
+fs.rmSync(path.join(rollbackReinit, '.cursor', 'hooks.json'), { force: true });
+fs.mkdirSync(path.join(rollbackReinit, '.cursor', 'hooks.json'));
+const reinit = runCli(rollbackReinit, ['init', 'cursor', '--preset', 'next']);
+assert.equal(reinit.status, 1);
+assert.equal(
+  fs.existsSync(path.join(rollbackReinit, '.cursor', 'rules', 'mine.mdc')),
+  true,
+  'failed re-init rollback must not delete pre-existing consumer files',
+);
+
+// `--preset ""` is a missing value, not a silent fall back to the default.
+const emptyPreset = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-empty-preset-'));
+const emptyPresetResult = runCli(emptyPreset, ['init', 'cursor', '--preset', '']);
+assert.equal(emptyPresetResult.status, 1);
+assert.match(emptyPresetResult.stderr, /Missing value for --preset/);
+
+// Unknown flags are rejected.
+const unknownFlag = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-unknown-flag-'));
+const unknownFlagResult = runCli(unknownFlag, ['init', 'cursor', '--preset', 'next', '--bogus']);
+assert.equal(unknownFlagResult.status, 1);
+assert.match(unknownFlagResult.stderr, /Unknown option: --bogus/);
+
+// Consumer MCP servers survive clean cursor (only shipped keys are stripped).
+const mcpExtra = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-mcp-extra-'));
+runInit(cli, mcpExtra, 'cursor', 'next');
+const mcpExtraPath = path.join(mcpExtra, '.cursor', 'mcp.json');
+const mcpExtraJson = readJson(mcpExtraPath);
+mcpExtraJson.mcpServers.myPrivate = { command: 'my-server' };
+fs.writeFileSync(mcpExtraPath, `${JSON.stringify(mcpExtraJson, null, 2)}\n`);
+runClean(mcpExtra, 'cursor');
+const mcpAfter = readJson(mcpExtraPath);
+assert.ok(mcpAfter.mcpServers.myPrivate, 'consumer MCP server must survive clean cursor');
+assert.equal(
+  Object.hasOwn(mcpAfter.mcpServers, 'context7'),
+  false,
+  'shipped MCP server must be stripped by clean cursor',
+);
+
 const multiClean = runCli(multiDir, ['clean', 'multi']);
 assert.equal(multiClean.status, 1);
 assert.match(`${multiClean.stderr}${multiClean.stdout}`, /clean multi is not supported/);
@@ -655,6 +775,17 @@ for (const dir of [
   collision,
   symlinked,
   outsideDir,
+  ownedClean,
+  noManifest,
+  traversal,
+  symlinkInit,
+  symlinkTarget,
+  mavisLink,
+  mavisTarget,
+  rollbackReinit,
+  emptyPreset,
+  unknownFlag,
+  mcpExtra,
   ...lastInitDirs,
 ]) {
   fs.rmSync(dir, { recursive: true, force: true });

package/scripts/test-mavis-context-budget.mjs

@@ -11,7 +11,7 @@ import { getStackProfile } from './lib/stack-platform-profiles.mjs';
 
 const scriptDirectory = path.dirname(fileURLToPath(import.meta.url));
 const presetsRoot = path.join(scriptDirectory, '..', 'presets');
-const LINE_CAP = 170;
+const LINE_CAP = 200;
 const PLATFORM_SENTINELS = ['.mavis/AGENTS.md', 'status.json', '~/.minimax'];
 
 function nonemptyLines(text) {

package/scripts/test-opencode-context-budget.mjs

@@ -10,7 +10,7 @@ import { getStackProfile } from './lib/stack-platform-profiles.mjs';
 
 const scriptDirectory = path.dirname(fileURLToPath(import.meta.url));
 const presetsRoot = path.join(scriptDirectory, '..', 'presets');
-const LINE_CAP = 170;
+const LINE_CAP = 200;
 const PLATFORM_SENTINELS = ['.opencode/AGENTS.md', 'status.json'];
 
 function nonemptyLines(text) {