@bonesofspring/ai-rules 0.2.26 → 0.2.28

package/scripts/sync-claude-settings.mjs

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+/**
+ * Generate (and keep fresh) `presets/claude/<stack>/settings.json` from the
+ * stack profile's `bashPermission`. Claude Code's settings.json uses
+ * `permissions.deny` / `permissions.ask` (glob patterns). We map:
+ *   - `<perm>`: "deny" → `permissions.deny`
+ *   - `<perm>`: "ask"  → `permissions.ask`
+ * (`allow` entries are ignored since they are not needed for the harness.)
+ *
+ * Idempotent: rewrites every stack. Claude presets are hand-maintained, so
+ * this script keeps them aligned with the StackProfile in
+ * `stack-platform-profiles.mjs` — run after editing `bashPermission` there.
+ *
+ * Usage: node scripts/sync-claude-settings.mjs
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { loadReleasedStacks } from './lib/generate-adapter-common.mjs';
+import { getStackProfile } from './lib/stack-platform-profiles.mjs';
+
+const scriptDirectory = path.dirname(fileURLToPath(import.meta.url));
+const packageRoot = path.join(scriptDirectory, '..');
+const presetsRoot = path.join(packageRoot, 'presets');
+
+function buildClaudePermissions(bashPermission) {
+  const deny = [];
+  const ask = [];
+  for (const [pattern, action] of Object.entries(bashPermission || {})) {
+    if (pattern === '*') continue;
+    if (action === 'deny') deny.push(`Bash(${pattern})`);
+    else if (action === 'ask') ask.push(`Bash(${pattern})`);
+  }
+  return { deny: deny.sort(), ask: ask.sort() };
+}
+
+function sync(stack) {
+  const profile = getStackProfile(stack);
+  const permissions = buildClaudePermissions(profile.bashPermission);
+  const settings = {
+    $schema: 'https://json.schemastore.org/claude-code-settings.json',
+    permissions,
+  };
+  const dest = path.join(presetsRoot, 'claude', stack, 'settings.json');
+  fs.mkdirSync(path.dirname(dest), { recursive: true });
+  fs.writeFileSync(dest, `${JSON.stringify(settings, null, 2)}\n`);
+  console.log(`claude/${stack}: wrote ${path.relative(packageRoot, dest)}`);
+}
+
+function main() {
+  for (const stack of loadReleasedStacks(presetsRoot, 'opencode')) {
+    sync(stack);
+  }
+}
+
+main();

package/scripts/test-agent-task-metrics-hooks.mjs

@@ -994,12 +994,12 @@ for (const hook of hooks) {
     const elapsed = Date.now() - releaseAt;
     assert.equal(exitCode, 0, `${hook}: hook did not exit 0 after lock release (stderr=${stderr.slice(0, 400)})`);
 
-    // The hook's waitForMetricsLock busy-waits on EEXIST in 10 ms slices; with a
-    // 60 ms hold the child should have been blocked for >= holdMs and run to
-    // completion in well under the 2 s ceiling. Both assertions guard against
-    // regressions to the fake Atomics.wait impl (which never blocked).
+    // The hook's waitForMetricsLock busy-waits on EEXIST in 10 ms slices. The
+    // "still alive while held" assertion above proves the lock actually blocked;
+    // this bound only catches a permanently stuck implementation. It is generous
+    // on purpose: bash + node startup under loaded CI regularly exceeds 1.5 s.
     assert.ok(elapsed >= 1, `${hook}: hook finished suspiciously fast after lock release (${elapsed} ms)`);
-    assert.ok(elapsed < 1500, `${hook}: hook took ${elapsed} ms after lock release — lock impl may be stuck`);
+    assert.ok(elapsed < 10000, `${hook}: hook took ${elapsed} ms after lock release — lock impl may be stuck`);
     const ledger = readJson(metricsPath);
     const finished = ledger.events.find(
       (event) => event.type === 'attempt_finished' && event.attemptId === attemptId,

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-cli-mcp-merge.mjs

@@ -154,6 +154,60 @@ try {
   assert.equal(fs.existsSync(path.join(mavisDir, '.minimax')), false);
   fs.rmSync(mavisDir, { recursive: true, force: true });
 
+  // OpenCode re-init unions preset instruction paths and fills missing bash keys.
+  const freshOc = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-oc-fresh-'));
+  init(freshOc, 'opencode', 'next');
+  const freshOcJson = readJson(path.join(freshOc, 'opencode.json'));
+  assert.ok(Array.isArray(freshOcJson.instructions), 'fresh opencode.json should have instructions');
+  assert.ok(freshOcJson.instructions.includes('.opencode/AGENTS.md'));
+  assert.ok(freshOcJson.permission, 'fresh opencode.json should have permission');
+  assert.ok(freshOcJson.permission.bash, 'fresh opencode.json should have permission.bash');
+  assert.equal(freshOcJson.permission.bash['git commit *'], 'deny');
+  assert.equal(freshOcJson.permission.bash['git push *'], 'deny');
+  assert.equal(freshOcJson.permission.bash['npx jest*'], 'deny');
+  const presetInstructions = freshOcJson.instructions.slice();
+  const presetBash = { ...freshOcJson.permission.bash };
+  fs.rmSync(freshOc, { recursive: true, force: true });
+
+  const repeatOc = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-oc-repeat-'));
+  init(repeatOc, 'opencode', 'next');
+  const consumerInstructions = ['.opencode/AGENTS.md', 'CONSUMER-RULE.md'];
+  const consumerBash = { '*': 'allow', 'git push *': 'allow', 'rm -rf /': 'deny' };
+  writeJson(path.join(repeatOc, 'opencode.json'), {
+    $schema: 'https://opencode.ai/config.json',
+    instructions: consumerInstructions,
+    permission: { bash: consumerBash },
+    mcp: { context7: { type: 'local', command: ['npx', '-y', '@upstash/context7-mcp@4.0.2'] } },
+    customNote: true,
+  });
+  init(repeatOc, 'opencode', 'next');
+  const preserved = readJson(path.join(repeatOc, 'opencode.json'));
+  assert.deepEqual(
+    preserved.instructions,
+    [...consumerInstructions, ...presetInstructions.filter((item) => !consumerInstructions.includes(item))],
+    'preset instruction paths are unioned; consumer extras stay first',
+  );
+  assert.equal(preserved.permission.bash['git push *'], 'allow', 'consumer bash override wins');
+  assert.equal(preserved.permission.bash['rm -rf /'], 'deny', 'consumer extra bash key stays');
+  assert.equal(preserved.permission.bash['git commit *'], presetBash['git commit *'], 'missing preset bash key is filled');
+  assert.equal(preserved.customNote, true, 'consumer custom keys preserved');
+  fs.rmSync(repeatOc, { recursive: true, force: true });
+
+  const emptyOc = fs.mkdtempSync(path.join(os.tmpdir(), 'ai-rules-oc-empty-'));
+  init(emptyOc, 'opencode', 'next');
+  writeJson(path.join(emptyOc, 'opencode.json'), {
+    $schema: 'https://opencode.ai/config.json',
+    instructions: [],
+    permission: {},
+    customNote: true,
+  });
+  init(emptyOc, 'opencode', 'next');
+  const filled = readJson(path.join(emptyOc, 'opencode.json'));
+  assert.deepEqual(filled.instructions, presetInstructions, 'empty instructions receive the preset list');
+  assert.deepEqual(filled.permission.bash, presetBash, 'missing bash object receives the preset map');
+  assert.equal(filled.customNote, true);
+  fs.rmSync(emptyOc, { recursive: true, force: true });
+
   console.log('test-cli-mcp-merge: ok');
 } finally {
   fs.rmSync(tmp, { 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) {