@bonesofspring/ai-rules 0.2.21 → 0.2.23

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

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+/**
+ * P1 context budget: root AGENTS + .mavis/AGENTS combined nonempty lines ≤ 170.
+ * Critical-policy sentinels must appear in the pair.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { loadReleasedMavisStacks } from './lib/discover-hooks.mjs';
+
+const scriptDirectory = path.dirname(fileURLToPath(import.meta.url));
+const presetsRoot = path.join(scriptDirectory, '..', 'presets');
+const LINE_CAP = 170;
+const SENTINELS = [
+  'next-app-core',
+  'package-manager',
+  'code-quality-and-refactoring',
+  'ai-local-overlay',
+  '.mavis/AGENTS.md',
+  'status.json',
+  '~/.minimax',
+];
+
+function nonemptyLines(text) {
+  return text.split(/\r?\n/).filter((line) => line.trim().length > 0).length;
+}
+
+const stacks = loadReleasedMavisStacks(presetsRoot);
+if (stacks.length === 0) {
+  console.log('ok mavis context-budget: no released stacks');
+  process.exit(0);
+}
+
+let failed = 0;
+for (const stack of stacks) {
+  const root = path.join(presetsRoot, 'mavis', stack);
+  const repoAgents = fs.readFileSync(path.join(root, 'REPO_AGENTS.md'), 'utf8');
+  const mavisAgents = fs.readFileSync(path.join(root, 'MAVIS.md'), 'utf8');
+  const combined = `${repoAgents}\n${mavisAgents}`;
+  const count = nonemptyLines(repoAgents) + nonemptyLines(mavisAgents);
+  if (count > LINE_CAP) {
+    console.error(`FAIL mavis/${stack}: entry nonempty lines ${count} > ${LINE_CAP}`);
+    failed += 1;
+  } else {
+    console.log(`ok mavis/${stack}: entry nonempty lines ${count} (cap ${LINE_CAP})`);
+  }
+  for (const sentinel of SENTINELS) {
+    if (!combined.includes(sentinel)) {
+      console.error(`FAIL mavis/${stack}: missing critical sentinel ${sentinel}`);
+      failed += 1;
+    }
+  }
+}
+
+process.exit(failed === 0 ? 0 : 1);

package/scripts/test-mavis-orchestration.mjs

@@ -0,0 +1,649 @@
+#!/usr/bin/env node
+/**
+ * P2 Mavis orchestration on `.mavis/team` + P3 semi-auto labeling.
+ * Native Team is not a lifecycle writer.
+ */
+import assert from 'node:assert/strict';
+import { execFileSync, spawn } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const scriptDirectory = path.dirname(fileURLToPath(import.meta.url));
+const packageDirectory = path.resolve(scriptDirectory, '..');
+const hook = path.join(
+  packageDirectory,
+  'presets',
+  'mavis',
+  'next',
+  'hooks',
+  'chain-team-phases.sh',
+);
+const contract = JSON.parse(
+  fs.readFileSync(
+    path.join(packageDirectory, 'presets', 'mavis', 'platform-contract.json'),
+    'utf8',
+  ),
+);
+
+assert.equal(fs.existsSync(hook), true, 'mavis/next chain hook must exist');
+assert.equal(
+  fs.existsSync(path.join(packageDirectory, 'presets', 'mavis', 'next', 'hooks.json')),
+  false,
+  'Mavis must not ship hooks.json',
+);
+assert.equal(contract.nativeCapabilities.projectHooks.status, 'unknown');
+assert.equal(contract.mcp.mode, 'fallback-manual-import');
+console.log('ok P3 semi-auto: projectHooks unknown, no hooks.json');
+
+function readJson(filePath) {
+  return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+}
+
+function writeJson(filePath, value) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+function invokeHook(workingDirectory, payload) {
+  return execFileSync('bash', [hook], {
+    cwd: workingDirectory,
+    encoding: 'utf8',
+    input: JSON.stringify(payload),
+  });
+}
+
+function writeTask(root, slug, pipeline, status, metrics, artifacts = {}) {
+  const teamRoot = path.join(root, '.mavis', 'team');
+  const taskDirectory = path.join(teamRoot, 'tasks', slug);
+  fs.mkdirSync(taskDirectory, { recursive: true });
+  writeJson(path.join(teamRoot, 'active-task.json'), { slug });
+  writeJson(path.join(taskDirectory, 'pipeline.json'), pipeline);
+  writeJson(path.join(taskDirectory, 'status.json'), {
+    executionMode: 'manual-chain',
+    ...status,
+  });
+  writeJson(path.join(taskDirectory, 'metrics.json'), metrics);
+  for (const [name, content] of Object.entries(artifacts)) {
+    fs.writeFileSync(path.join(taskDirectory, name), content);
+  }
+  return taskDirectory;
+}
+
+function receipt(id, producer, attemptId, at) {
+  return {
+    id,
+    producer,
+    status: 'ready',
+    authoritativePaths: [`${id}.md`],
+    acceptanceCriteriaIds: [],
+    taskIds: [],
+    timestamps: { createdAt: at, updatedAt: at, completedAt: at },
+    receipt: {
+      outcome: 'completed',
+      attemptId,
+      summary: `${id} complete`,
+      evidencePaths: [`${id}.md`],
+    },
+  };
+}
+
+async function main() {
+{
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'mavis-p2-'));
+  try {
+    const runId = 'mavis-p2-run';
+    const analystId = `${runId}:step-0:task-analyst:attempt-1`;
+    const at = new Date().toISOString();
+    const taskDirectory = writeTask(
+      root,
+      'mavis-p2',
+      {
+        autoChain: true,
+        humanGates: ['after:task-analyst'],
+        steps: [
+          { agent: 'task-analyst', artifactOutputId: 'analysis' },
+          { agent: 'feature-developer', artifactOutputId: 'implementation' },
+          { agent: 'build-verifier', artifactOutputId: 'validation' },
+        ],
+      },
+      {
+        slug: 'mavis-p2',
+        intent: 'feature',
+        pipelineIndex: 0,
+        currentAgent: 'task-analyst',
+        phase: 'executing',
+        state: 'completed',
+        activeAttempts: {
+          [analystId]: {
+            agent: 'task-analyst',
+            stepIndex: 0,
+            attempt: 1,
+            startedAt: at,
+            parallelGroupId: null,
+          },
+        },
+        metricsRunId: runId,
+      },
+      {
+        schemaVersion: 1,
+        task: {
+          runId,
+          slug: 'mavis-p2',
+          preset: 'ai-rules',
+          stack: 'next',
+          platform: 'mavis',
+          intent: 'feature',
+          profile: 'test',
+        },
+        events: [
+          { eventId: `${runId}:task_started`, type: 'task_started', at },
+          {
+            eventId: `${runId}:analyst-start`,
+            type: 'attempt_started',
+            attemptId: analystId,
+            agent: 'task-analyst',
+            stepIndex: 0,
+            attempt: 1,
+            at,
+          },
+        ],
+      },
+      {
+        'brief.md': '# brief\n',
+        'decomposition.md': '# decomp\n',
+        'artifact-manifest.json': `${JSON.stringify(
+          {
+            schemaVersion: 1,
+            slug: 'mavis-p2',
+            updatedAt: at,
+            artifacts: [receipt('analysis', 'task-analyst', analystId, at)],
+          },
+          null,
+          2,
+        )}\n`,
+      },
+    );
+
+    const afterAnalyst = JSON.parse(invokeHook(root, { status: 'completed', attemptId: analystId }));
+    const gated = readJson(path.join(taskDirectory, 'status.json'));
+    assert.equal(gated.executionMode, 'manual-chain');
+    assert.equal(gated.awaitingHumanGate, true, 'P2 must stop at after:task-analyst');
+    assert.ok(gated.activeHumanGateEventId, 'P2 must record human_gate_started');
+    assert.deepEqual(afterAnalyst, {}, 'human gate pause returns empty hook output');
+
+    const resume = JSON.parse(
+      invokeHook(root, {
+        status: 'completed',
+        action: 'end_human_gate',
+        activateNext: true,
+      }),
+    );
+    const afterGate = readJson(path.join(taskDirectory, 'status.json'));
+    assert.equal(afterGate.awaitingHumanGate, false);
+    assert.equal(afterGate.currentAgent, 'feature-developer');
+    assert.match(resume.followup_message || '', /feature-developer/);
+
+    const developerId = Object.keys(afterGate.activeAttempts).find((id) =>
+      id.includes('feature-developer'),
+    );
+    const later = new Date().toISOString();
+    writeJson(path.join(taskDirectory, 'artifact-manifest.json'), {
+      schemaVersion: 1,
+      slug: 'mavis-p2',
+      updatedAt: later,
+      artifacts: [
+        receipt('analysis', 'task-analyst', analystId, at),
+        receipt('implementation', 'feature-developer', developerId, later),
+      ],
+    });
+    fs.writeFileSync(path.join(taskDirectory, 'implementation.md'), '# impl\n');
+    invokeHook(root, { status: 'completed', attemptId: developerId });
+    const afterDev = readJson(path.join(taskDirectory, 'status.json'));
+    assert.equal(afterDev.currentAgent, 'build-verifier');
+    console.log('ok P2: route → receipt → human gate → continue → verifier');
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+}
+
+{
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'mavis-stale-'));
+  try {
+    const runId = 'mavis-stale-run';
+    const attemptId = `${runId}:step-2:code-reviewer:attempt-1`;
+    const staleAt = '2026-01-01T00:00:00.000Z';
+    const startedAt = '2026-01-01T00:00:05.000Z';
+    const taskDirectory = writeTask(
+      root,
+      'mavis-stale',
+      {
+        autoChain: true,
+        steps: [
+          { agent: 'feature-developer', artifactOutputId: 'implementation' },
+          { agent: 'build-verifier', artifactOutputId: 'validation' },
+          { agent: 'code-reviewer', artifactOutputId: 'review' },
+        ],
+      },
+      {
+        slug: 'mavis-stale',
+        intent: 'feature',
+        pipelineIndex: 2,
+        currentAgent: 'code-reviewer',
+        phase: 'executing',
+        state: 'awaiting_artifact_receipt',
+        activeAttempts: {
+          [attemptId]: {
+            agent: 'code-reviewer',
+            stepIndex: 2,
+            attempt: 1,
+            startedAt,
+            parallelGroupId: null,
+          },
+        },
+        metricsRunId: runId,
+      },
+      {
+        schemaVersion: 1,
+        task: {
+          runId,
+          slug: 'mavis-stale',
+          preset: 'ai-rules',
+          stack: 'next',
+          platform: 'mavis',
+          intent: 'feature',
+          profile: 'test',
+        },
+        events: [
+          { eventId: `${runId}:task_started`, type: 'task_started', at: startedAt },
+          {
+            eventId: `${runId}:review-start`,
+            type: 'attempt_started',
+            attemptId,
+            agent: 'code-reviewer',
+            stepIndex: 2,
+            attempt: 1,
+            at: startedAt,
+          },
+        ],
+      },
+      {
+        'artifact-manifest.json': `${JSON.stringify(
+          {
+            schemaVersion: 1,
+            slug: 'mavis-stale',
+            updatedAt: staleAt,
+            artifacts: [receipt('review', 'code-reviewer', attemptId, staleAt)],
+          },
+          null,
+          2,
+        )}\n`,
+      },
+    );
+    assert.deepEqual(JSON.parse(invokeHook(root, { status: 'completed', attemptId })), {});
+    const status = readJson(path.join(taskDirectory, 'status.json'));
+    assert.equal(status.pipelineIndex, 2);
+    assert.equal(status.currentAgent, 'code-reviewer');
+    console.log('ok stale receipt ignored');
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+}
+
+{
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'mavis-retry-'));
+  try {
+    const runId = 'mavis-retry-run';
+    const reviewerId = `${runId}:step-1:code-reviewer:attempt-1`;
+    const at = new Date().toISOString();
+    const taskDirectory = writeTask(
+      root,
+      'mavis-retry',
+      {
+        autoChain: true,
+        steps: [
+          { agent: 'feature-developer', artifactOutputId: 'implementation' },
+          { agent: 'code-reviewer', artifactInputIds: ['implementation'], artifactOutputId: 'review' },
+        ],
+      },
+      {
+        slug: 'mavis-retry',
+        intent: 'review-only',
+        pipelineIndex: 1,
+        currentAgent: 'code-reviewer',
+        phase: 'executing',
+        state: 'in_progress',
+        activeAttempts: {
+          [reviewerId]: {
+            agent: 'code-reviewer',
+            stepIndex: 1,
+            attempt: 1,
+            startedAt: at,
+            parallelGroupId: null,
+          },
+        },
+        metricsRunId: runId,
+      },
+      {
+        schemaVersion: 1,
+        task: {
+          runId,
+          slug: 'mavis-retry',
+          preset: 'ai-rules',
+          stack: 'next',
+          platform: 'mavis',
+          intent: 'review-only',
+          profile: 'test',
+        },
+        events: [
+          { eventId: `${runId}:task_started`, type: 'task_started', at },
+          {
+            eventId: `${runId}:review-start`,
+            type: 'attempt_started',
+            attemptId: reviewerId,
+            agent: 'code-reviewer',
+            stepIndex: 1,
+            attempt: 1,
+            at,
+          },
+        ],
+      },
+      {
+        'review.md': '# review\nREQUEST_CHANGES\n',
+        'artifact-manifest.json': `${JSON.stringify(
+          {
+            schemaVersion: 1,
+            slug: 'mavis-retry',
+            updatedAt: at,
+            artifacts: [
+              {
+                id: 'review',
+                producer: 'code-reviewer',
+                status: 'blocked',
+                authoritativePaths: ['review.md'],
+                acceptanceCriteriaIds: [],
+                taskIds: [],
+                timestamps: { createdAt: at, updatedAt: at, completedAt: at },
+                receipt: {
+                  outcome: 'changes_requested',
+                  attemptId: reviewerId,
+                  summary: 'Review found blockers.',
+                  evidencePaths: ['review.md'],
+                },
+              },
+            ],
+          },
+          null,
+          2,
+        )}\n`,
+      },
+    );
+    const handoff = JSON.parse(invokeHook(root, { status: 'completed', attemptId: reviewerId }));
+    const status = readJson(path.join(taskDirectory, 'status.json'));
+    assert.equal(status.currentAgent, 'feature-developer');
+    assert.equal(status.retryAfterFix, 'code-reviewer');
+    assert.match(handoff.followup_message || '', /feature-developer/);
+    console.log('ok retry to nearest worker');
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+}
+
+{
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'mavis-parallel-'));
+  try {
+    const runId = 'mavis-parallel-run';
+    const starterId = `${runId}:step-0:starter:attempt-1`;
+    const at = '2026-01-01T00:00:00.000Z';
+    const taskDirectory = writeTask(
+      root,
+      'mavis-parallel',
+      {
+        autoChain: true,
+        steps: [
+          { agent: 'starter' },
+          { agent: ['alpha', 'beta'], parallel: true },
+          { agent: 'gamma' },
+        ],
+      },
+      {
+        slug: 'mavis-parallel',
+        intent: 'feature',
+        pipelineIndex: 0,
+        currentAgent: 'starter',
+        phase: 'executing',
+        state: 'completed',
+        activeAttempts: {
+          [starterId]: {
+            agent: 'starter',
+            stepIndex: 0,
+            attempt: 1,
+            startedAt: at,
+            parallelGroupId: null,
+          },
+        },
+        metricsRunId: runId,
+      },
+      {
+        schemaVersion: 1,
+        task: {
+          runId,
+          slug: 'mavis-parallel',
+          preset: 'ai-rules',
+          stack: 'next',
+          platform: 'mavis',
+          intent: 'feature',
+          profile: 'test',
+        },
+        events: [
+          { eventId: `${runId}:task_started`, type: 'task_started', at },
+          {
+            eventId: `${runId}:starter`,
+            type: 'attempt_started',
+            attemptId: starterId,
+            agent: 'starter',
+            stepIndex: 0,
+            attempt: 1,
+            at,
+          },
+        ],
+      },
+    );
+    invokeHook(root, { status: 'completed', attemptId: starterId });
+    const afterStart = readJson(path.join(taskDirectory, 'status.json'));
+    const alphaId = Object.keys(afterStart.activeAttempts).find((id) => id.includes('alpha'));
+    const betaId = Object.keys(afterStart.activeAttempts).find((id) => id.includes('beta'));
+    assert.ok(alphaId && betaId, 'parallel attempts must activate');
+    invokeHook(root, { status: 'completed', attemptId: betaId });
+    invokeHook(root, { status: 'completed', attemptId: alphaId });
+    const afterBoth = readJson(path.join(taskDirectory, 'status.json'));
+    assert.equal(afterBoth.currentAgent, 'gamma');
+    console.log('ok reverse-order parallel completion');
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+}
+
+{
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'mavis-lock-'));
+  try {
+    const runId = 'mavis-lock-run';
+    const attemptId = `${runId}:step-0:feature-developer:attempt-1`;
+    const at = '2026-01-01T00:00:00.000Z';
+    const taskDirectory = writeTask(
+      root,
+      'mavis-lock',
+      { autoChain: true, steps: [{ agent: 'feature-developer' }, { agent: 'build-verifier' }] },
+      {
+        slug: 'mavis-lock',
+        intent: 'feature',
+        pipelineIndex: 0,
+        currentAgent: 'feature-developer',
+        phase: 'executing',
+        state: 'in_progress',
+        activeAttempts: {
+          [attemptId]: {
+            agent: 'feature-developer',
+            stepIndex: 0,
+            attempt: 1,
+            startedAt: at,
+            parallelGroupId: null,
+          },
+        },
+        metricsRunId: runId,
+      },
+      {
+        schemaVersion: 1,
+        task: {
+          runId,
+          slug: 'mavis-lock',
+          preset: 'ai-rules',
+          stack: 'next',
+          platform: 'mavis',
+          intent: 'feature',
+          profile: 'test',
+        },
+        events: [
+          { eventId: `${runId}:task_started`, type: 'task_started', at },
+          {
+            eventId: `${runId}:dev-start`,
+            type: 'attempt_started',
+            attemptId,
+            agent: 'feature-developer',
+            stepIndex: 0,
+            attempt: 1,
+            at,
+          },
+        ],
+      },
+    );
+    const lockPath = path.join(taskDirectory, 'metrics.json.lock');
+    fs.writeFileSync(lockPath, 'held\n');
+    const first = new Promise((resolve, reject) => {
+      const child = spawn('bash', [hook], { cwd: root, stdio: ['pipe', 'pipe', 'pipe'] });
+      child.stdin.end(JSON.stringify({ status: 'completed', attemptId }));
+      child.on('close', (code) => (code === 0 ? resolve() : reject(new Error(`lock wait ${code}`))));
+    });
+    setTimeout(() => {
+      if (fs.existsSync(lockPath)) {
+        fs.unlinkSync(lockPath);
+      }
+    }, 50);
+    await first;
+    const finished = readJson(path.join(taskDirectory, 'metrics.json')).events.find(
+      (event) => event.type === 'attempt_finished' && event.attemptId === attemptId,
+    );
+    assert.ok(finished, 'lock-race must emit one attempt_finished');
+    console.log('ok metrics lock race');
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+}
+
+{
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'mavis-manual-'));
+  try {
+    fs.mkdirSync(path.join(root, '.mavis', 'hooks'), { recursive: true });
+    fs.copyFileSync(hook, path.join(root, '.mavis', 'hooks', 'chain-team-phases.sh'));
+    const runId = 'mavis-manual-run';
+    const analystId = `${runId}:step-0:task-analyst:attempt-1`;
+    const at = new Date().toISOString();
+    writeTask(
+      root,
+      'mavis-manual',
+      { autoChain: true, steps: [{ agent: 'task-analyst' }, { agent: 'feature-developer' }] },
+      {
+        slug: 'mavis-manual',
+        intent: 'feature',
+        pipelineIndex: 0,
+        currentAgent: 'task-analyst',
+        phase: 'executing',
+        state: 'completed',
+        activeAttempts: {
+          [analystId]: {
+            agent: 'task-analyst',
+            stepIndex: 0,
+            attempt: 1,
+            startedAt: at,
+            parallelGroupId: null,
+          },
+        },
+        metricsRunId: runId,
+      },
+      {
+        schemaVersion: 1,
+        task: {
+          runId,
+          slug: 'mavis-manual',
+          preset: 'ai-rules',
+          stack: 'next',
+          platform: 'mavis',
+          intent: 'feature',
+          profile: 'test',
+        },
+        events: [
+          { eventId: `${runId}:task_started`, type: 'task_started', at },
+          {
+            eventId: `${runId}:analyst`,
+            type: 'attempt_started',
+            attemptId: analystId,
+            agent: 'task-analyst',
+            stepIndex: 0,
+            attempt: 1,
+            at,
+          },
+        ],
+      },
+    );
+    const installed = path.join(root, '.mavis', 'hooks', 'chain-team-phases.sh');
+    const out = execFileSync('bash', [installed], {
+      cwd: root,
+      encoding: 'utf8',
+      input: JSON.stringify({ status: 'completed', attemptId: analystId }),
+    });
+    assert.match(JSON.parse(out).followup_message || '', /feature-developer/);
+    assert.equal(fs.existsSync(path.join(root, '.mavis', 'hooks.json')), false);
+    console.log('ok manual fallback on fresh fixture (semi-auto)');
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+}
+
+{
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'mavis-bad-pipeline-'));
+  try {
+    const taskDirectory = writeTask(
+      root,
+      'mavis-bad',
+      null,
+      {
+        slug: 'mavis-bad',
+        intent: 'feature',
+        pipelineIndex: 0,
+        currentAgent: 'task-analyst',
+        phase: 'executing',
+        state: 'in_progress',
+      },
+      { schemaVersion: 1, task: { runId: 'bad', slug: 'mavis-bad' }, events: [] },
+    );
+    fs.writeFileSync(
+      path.join(taskDirectory, 'pipeline.json'),
+      '{ "intent": "feature", "steps": [\n  { "agent": "task-analyst" }\n',
+    );
+    invokeHook(root, { status: 'completed', attemptId: 'x' });
+    const status = readJson(path.join(taskDirectory, 'status.json'));
+    assert.equal(status.state, 'blocked');
+    console.log('ok malformed pipeline blocked');
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+}
+
+  console.log('test-mavis-orchestration: ok');
+}
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});