@bonesofspring/ai-rules 0.2.21 → 0.2.22

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

@@ -892,4 +892,102 @@ for (const hook of hooks) {
   }
 }
 
-console.log(`Verified retry, parallel, skip, gate, manifest-reconcile, and aggregation lifecycle in ${hooks.length} hooks.`);
+// ---------------------------------------------------------------------------
+// Test — OD-1: parallel-stop lock race. The hook's waitForMetricsLock must
+// actually block a second writer when the lock file is held. We pre-acquire
+// `metrics.json.lock` (fs.openSync(_, 'wx') — same primitive the hook uses)
+// in the test, then invoke the hook concurrently; the hook must NOT acquire
+// the lock until the test releases it. Without the real lock primitive the
+// hook would race through, run the metrics write, and leave a corrupt ledger.
+// ---------------------------------------------------------------------------
+for (const hook of hooks) {
+  const root = fs.mkdtempSync(path.join(packageDirectory, '.agent-task-metrics-lock-race-'));
+  try {
+    const platform = hook.includes(`${path.sep}cursor${path.sep}`) ? 'cursor' : 'claude';
+    const runId = 'lock-race-run';
+    const attemptId = `${runId}:step-0:feature-developer:attempt-1`;
+    const taskDirectory = writeTask(
+      root,
+      hook,
+      'lock-race',
+      { autoChain: true, steps: [{ agent: 'feature-developer' }] },
+      {
+        slug: 'lock-race',
+        intent: 'feature',
+        pipelineIndex: 0,
+        currentAgent: 'feature-developer',
+        phase: 'executing',
+        state: 'completed',
+        activeAttempts: {
+          [attemptId]: {
+            agent: 'feature-developer',
+            stepIndex: 0,
+            attempt: 1,
+            startedAt: '2026-01-01T00:00:00.000Z',
+            parallelGroupId: null,
+          },
+        },
+        metricsRunId: runId,
+      },
+      {
+        schemaVersion: 1,
+        task: { runId, slug: 'lock-race', preset: 'ai-rules', stack: 'test', platform, intent: 'feature', profile: 'test' },
+        events: [
+          { eventId: `${runId}:task_started`, type: 'task_started', at: '2026-01-01T00:00:00.000Z' },
+          { eventId: `${runId}:start`, type: 'attempt_started', attemptId, agent: 'feature-developer', stepIndex: 0, attempt: 1, at: '2026-01-01T00:00:00.000Z' },
+        ],
+      },
+    );
+    const metricsPath = path.join(taskDirectory, 'metrics.json');
+    const lockPath = `${metricsPath}.lock`;
+
+    // Pre-acquire the lock the same way the hook does (fs.openSync 'wx').
+    const holderFd = fs.openSync(lockPath, 'wx');
+
+    // Spawn the hook while the lock is held. The hook must wait.
+    const child = spawn('bash', [hook], { cwd: root, stdio: ['pipe', 'pipe', 'pipe'] });
+    let stderr = '';
+    let stdout = '';
+    child.stderr.setEncoding('utf8');
+    child.stdout.setEncoding('utf8');
+    child.stderr.on('data', (chunk) => { stderr += chunk; });
+    child.stdout.on('data', (chunk) => { stdout += chunk; });
+    child.stdin.end(JSON.stringify({ status: 'completed', attemptId }));
+
+    // Give the child time to enter waitForMetricsLock and hit the EEXIST retry path.
+    const holdMs = 60;
+    await new Promise((resolve) => setTimeout(resolve, holdMs));
+    assert.ok(
+      child.exitCode === null,
+      `${hook}: hook exited prematurely while lock was held (stdout=${stdout.slice(0, 200)} stderr=${stderr.slice(0, 200)})`,
+    );
+
+    // Release the lock — child should now proceed.
+    const releaseAt = Date.now();
+    fs.closeSync(holderFd);
+    fs.unlinkSync(lockPath);
+
+    const exitCode = await new Promise((resolve, reject) => {
+      child.on('error', reject);
+      child.on('close', resolve);
+    });
+    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).
+    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`);
+    const ledger = readJson(metricsPath);
+    const finished = ledger.events.find(
+      (event) => event.type === 'attempt_finished' && event.attemptId === attemptId,
+    );
+    assert.ok(finished, `${hook}: lock-race did not emit attempt_finished; ledger=${JSON.stringify(ledger.events.map((e) => e.type))}`);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+}
+
+console.log(`Verified retry, parallel, skip, gate, manifest-reconcile, lock-race, and aggregation lifecycle in ${hooks.length} hooks.`);

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

@@ -408,4 +408,103 @@ for (const hook of HOOKS_WITH_OPENSPEC) {
   }
 }
 
-console.log(`Verified openspec-author handoff, qa-tester handoff, pipeline misparse blocking, legacy fallback, and writeStatus durability in ${hooks.length} hooks.`);
+// ---------------------------------------------------------------------------
+// Test 6 — stale `attemptId` rejection (WP-1 receipt-binding callout):
+// the hook's `readBoundReceiptOutcome` rejects entries whose `receipt.attemptId`
+// does not match the active attempt, even when `completedAt` is fresh. A
+// receipt bound to a prior attempt ID (e.g. attempt-1 reused after a retry
+// recycled the slot) must not advance the pipeline.
+// ---------------------------------------------------------------------------
+for (const hook of hooks) {
+  const root = fs.mkdtempSync(path.join(packageDirectory, '.stale-attempt-id-'));
+  try {
+    const platform = platformFor(hook);
+    const runId = 'stale-attempt-id-run';
+    const devAttemptId = `${runId}:step-0:feature-developer:attempt-2`;
+    const freshIso = new Date().toISOString();
+    writeTask(
+      root,
+      hook,
+      'stale-attempt-id',
+      {
+        autoChain: true,
+        steps: [
+          { agent: 'feature-developer', artifactOutputId: 'implementation' },
+          { agent: 'build-verifier', artifactInputIds: ['implementation'], artifactOutputId: 'validation' },
+        ],
+      },
+      {
+        slug: 'stale-attempt-id',
+        intent: 'feature',
+        pipelineIndex: 0,
+        currentAgent: 'feature-developer',
+        phase: 'executing',
+        state: 'in_progress',
+        activeAttempts: {
+          [devAttemptId]: {
+            agent: 'feature-developer',
+            stepIndex: 0,
+            attempt: 2,
+            startedAt: freshIso,
+            parallelGroupId: null,
+          },
+        },
+        metricsRunId: runId,
+      },
+      {
+        schemaVersion: 1,
+        task: { runId, slug: 'stale-attempt-id', preset: 'ai-rules', stack: 'test', platform, intent: 'feature', profile: 'standard' },
+        events: [
+          { eventId: `${runId}:task_started`, type: 'task_started', at: freshIso },
+          { eventId: `${runId}:dev-start`, type: 'attempt_started', attemptId: devAttemptId, agent: 'feature-developer', stepIndex: 0, attempt: 2, at: freshIso },
+        ],
+      },
+      {
+        'artifact-manifest.json': `${JSON.stringify(
+          {
+            schemaVersion: 1,
+            slug: 'stale-attempt-id',
+            updatedAt: freshIso,
+            artifacts: [
+              {
+                id: 'implementation',
+                producer: 'feature-developer',
+                status: 'completed',
+                authoritativePaths: ['implementation.md'],
+                acceptanceCriteriaIds: ['AC-1'],
+                taskIds: ['T1'],
+                timestamps: { createdAt: freshIso, updatedAt: freshIso, completedAt: freshIso },
+                receipt: {
+                  outcome: 'completed',
+                  // Stale: belongs to attempt-1 of the same (step, agent); the active attempt is attempt-2.
+                  attemptId: `${runId}:step-0:feature-developer:attempt-1`,
+                  summary: 'Receipt bound to a prior attempt; should be rejected.',
+                  evidencePaths: ['implementation.md'],
+                },
+              },
+            ],
+          },
+          null,
+          2,
+        )}\n`,
+      },
+    );
+
+    const taskDirectory = path.join(root, `.${platform}`, 'team', 'tasks', 'stale-attempt-id');
+    const parsed = JSON.parse(invokeHook(hook, root, devAttemptId));
+    assert.deepEqual(parsed, {}, `${hook}: stale-attemptId receipt must not hand off`);
+    const status = readJson(path.join(taskDirectory, 'status.json'));
+    assert.equal(status.pipelineIndex, 0, `${hook}: stale-attemptId receipt advanced the pipeline`);
+    assert.equal(status.currentAgent, 'feature-developer', `${hook}: stale-attemptId receipt changed the active producer`);
+    assert.equal(status.state, 'awaiting_artifact_receipt', `${hook}: stale-attemptId did not enter receipt-wait state (got: ${status.state})`);
+    assert.ok(status.activeAttempts[devAttemptId], `${hook}: stale-attemptId consumed the active attempt`);
+    const finished = readJson(path.join(taskDirectory, 'metrics.json')).events.filter(
+      (event) => event.type === 'attempt_finished' && event.attemptId === devAttemptId,
+    );
+    assert.equal(finished.length, 0, `${hook}: stale-attemptId emitted terminal metrics`);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+}
+
+console.log(`Verified openspec-author handoff, qa-tester handoff, pipeline misparse blocking, legacy fallback, writeStatus durability, and stale attemptId rejection in ${hooks.length} hooks.`);

package/scripts/test-task-router-intents-fixtures.mjs

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+// Fixtures for check-task-router-intents.sh.
+//
+// Scenario: rename the frontmatter `name:` of an existing shipped agent
+// (cursor/next/agents/build-verifier.md → `build-verifier-renamed`) and
+// confirm the check FAILS. Then revert and confirm it PASSES.
+//
+// Why a separate fixture file: the check is a shell + Python script under
+// `scripts/`, not an in-process module, so we exercise it end-to-end via
+// `execFileSync` against a temp copy of `agents/` (mirroring the pattern in
+// `test-chain-team-phases-coverage.mjs` and `test-cli-mcp-merge.mjs`).
+//
+// The fixture operates on a *copy* of `presets/cursor/next/agents/` so the
+// real preset tree is never mutated, even on assertion failure.
+
+import assert from 'node:assert/strict';
+import { execFileSync } 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 checkScript = path.join(scriptDirectory, 'check-task-router-intents.sh');
+
+function runCheck(env) {
+  try {
+    return {
+      exitCode: 0,
+      stdout: execFileSync('bash', [checkScript], { env, encoding: 'utf8' }),
+    };
+  } catch (error) {
+    return {
+      exitCode: error.status ?? 1,
+      stdout: `${error.stdout ?? ''}${error.stderr ?? ''}`,
+    };
+  }
+}
+
+function copyAgentsDir(sourceAgentsDir) {
+  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'task-router-intents-'));
+  // Mirror full preset tree so the Python script's iteration works.
+  const sourcePresetsDir = path.join(packageDirectory, 'presets');
+  const targetPresetsDir = path.join(tempRoot, 'packages', 'ai-rules', 'presets');
+  fs.mkdirSync(targetPresetsDir, { recursive: true });
+  copyTree(sourcePresetsDir, targetPresetsDir);
+  return tempRoot;
+}
+
+function copyTree(source, destination) {
+  for (const entry of fs.readdirSync(source, { withFileTypes: true })) {
+    const src = path.join(source, entry.name);
+    const dest = path.join(destination, entry.name);
+    if (entry.isDirectory()) {
+      fs.mkdirSync(dest, { recursive: true });
+      copyTree(src, dest);
+    } else if (entry.isFile()) {
+      fs.copyFileSync(src, dest);
+    }
+  }
+}
+
+function setEnvPresetRoot(tempRoot) {
+  return { ...process.env, AI_RULES_PRESETS_ROOT: path.join(tempRoot, 'packages', 'ai-rules', 'presets') };
+}
+
+// Test 1 — rename frontmatter `name:` and assert the script returns non-zero.
+{
+  const tempRoot = copyAgentsDir(path.join(packageDirectory, 'presets', 'cursor', 'next', 'agents'));
+  try {
+    const agentFile = path.join(tempRoot, 'packages', 'ai-rules', 'presets', 'cursor', 'next', 'agents', 'build-verifier.md');
+    const original = fs.readFileSync(agentFile, 'utf8');
+    const renamed = original.replace(/^name:\s*build-verifier\s*$/m, 'name: build-verifier-renamed');
+    assert.notStrictEqual(renamed, original, 'rename pattern must match exactly one line');
+    fs.writeFileSync(agentFile, renamed);
+
+    const result = runCheck(setEnvPresetRoot(tempRoot));
+    assert.notStrictEqual(
+      result.exitCode,
+      0,
+      `expected FAIL when name frontmatter does not match stem; got exit=${result.exitCode}\n${result.stdout}`,
+    );
+    assert.match(
+      result.stdout,
+      /task-router vs agents drift/,
+      'expected drift failure message in output',
+    );
+  } finally {
+    fs.rmSync(tempRoot, { recursive: true, force: true });
+  }
+}
+
+// Test 2 — revert and assert the script returns zero.
+{
+  const tempRoot = copyAgentsDir(path.join(packageDirectory, 'presets', 'cursor', 'next', 'agents'));
+  try {
+    const result = runCheck(setEnvPresetRoot(tempRoot));
+    assert.strictEqual(
+      result.exitCode,
+      0,
+      `expected PASS on unmodified copy; got exit=${result.exitCode}\n${result.stdout}`,
+    );
+  } finally {
+    fs.rmSync(tempRoot, { recursive: true, force: true });
+  }
+}
+
+console.log('OK: check-task-router-intents.sh fixture tests passed');