@bonesofspring/ai-rules 0.2.20 → 0.2.22

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

@@ -0,0 +1,510 @@
+#!/usr/bin/env node
+// Targeted tests for chain-team-phases.sh fixes that prevent `/task` pipelines
+// from silently skipping or stalling on modern roles.
+//
+// Coverage:
+//   1. openspec-author handoff path: the AGENT_HANDOFF['openspec-author']
+//      entry must be emitted so the orchestrator invokes the agent; the
+//      DEFAULT_ARTIFACT_OUTPUT_IDS['openspec-author'] entry must match the
+//      manifest's `openspec-change` receipt so the hook advances instead of
+//      stalling in `awaiting_artifact_receipt`.
+//   2. QA / unit / playwright / instrumentation / integration / xcuitest
+//      agents must have both AGENT_HANDOFF and DEFAULT_ARTIFACT_OUTPUT_IDS
+//      entries (the symmetric check is in check-chain-hook-coverage.sh; here
+//      we drive a full pipeline step to make sure receipts reconcile).
+//   3. Pipeline.json parse error: a malformed pipeline.json that still
+//      carries an `intent` field must NOT fall through to legacyFlow; the
+//      hook must write `state: blocked` and emit a followup_message that
+//      mentions `pipeline.json` so the orchestrator surfaces the error.
+//   4. Legacy flow fallback: a missing pipeline.json must still invoke
+//      legacyFlow() (analysis → development → review → testing chain).
+//   5. writeStatus durability: status.json must be durable (fsync) before the
+//      hook returns. We assert that a second reader immediately after the
+//      hook returns sees the new state.
+
+import assert from 'node:assert/strict';
+import { execFileSync, spawn } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const scriptDirectory = path.dirname(fileURLToPath(import.meta.url));
+const packageDirectory = path.resolve(scriptDirectory, '..');
+const presetsDirectory = path.join(packageDirectory, 'presets');
+
+const hooks = [
+  ...fs.readdirSync(path.join(presetsDirectory, 'cursor')).map((stack) => path.join(presetsDirectory, 'cursor', stack, 'hooks', 'chain-team-phases.sh')),
+  ...fs.readdirSync(path.join(presetsDirectory, 'claude')).map((stack) => path.join(presetsDirectory, 'claude', stack, 'hooks', 'chain-team-phases.sh')),
+];
+
+assert.equal(hooks.length, 20, `expected 20 packaged hooks (10 stacks × 2 platforms), got ${hooks.length}`);
+
+// mcp-ts does not ship openspec-author (per preset-no-cross-stack-leakage).
+const HOOKS_WITH_OPENSPEC = hooks.filter((hook) => !hook.includes(`${path.sep}mcp-ts${path.sep}`));
+assert.equal(HOOKS_WITH_OPENSPEC.length, 18, 'expected 18 hooks to cover openspec-author');
+
+function readJson(filePath) {
+  return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+}
+
+function writeJson(filePath, value) {
+  fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+function invokeHook(hook, workingDirectory, attemptId, payload = {}) {
+  return execFileSync('bash', [hook], {
+    cwd: workingDirectory,
+    encoding: 'utf8',
+    input: JSON.stringify({ status: 'completed', attemptId, ...payload }),
+  });
+}
+
+function platformFor(hook) {
+  return hook.includes(`${path.sep}cursor${path.sep}`) ? 'cursor' : 'claude';
+}
+
+function writeTask(root, hook, slug, pipeline, status, metrics, artifacts = {}) {
+  const platform = platformFor(hook);
+  const teamRoot = path.join(root, `.${platform}`, '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'), 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, platform };
+}
+
+const todayIso = '2026-08-21T00:00:00.000Z';
+const earlierIso = '2026-08-21T00:00:01.000Z';
+
+// ---------------------------------------------------------------------------
+// Test 1 — openspec-author handoff: the hook must emit a followup_message that
+// references openspec-author and the openspec-change scope, and the default
+// artifact id must match the manifest receipt for `state` to advance.
+// ---------------------------------------------------------------------------
+for (const hook of HOOKS_WITH_OPENSPEC) {
+  const root = fs.mkdtempSync(path.join(packageDirectory, '.openspec-handoff-'));
+  try {
+    const runId = 'openspec-handoff-run';
+    const platform = platformFor(hook);
+    const analystAttemptId = `${runId}:step-0:task-analyst:attempt-1`;
+    const { taskDirectory } = writeTask(
+      root,
+      hook,
+      'openspec-handoff',
+      {
+        intent: 'openspec-change',
+        profile: 'standard',
+        steps: [
+          { agent: 'task-analyst', label: 'Analyze' },
+          { agent: 'openspec-author', label: 'Author spec change', scope: 'openspec:MEDCARD-11762' },
+        ],
+        humanGates: [],
+      },
+      {
+        slug: 'openspec-handoff',
+        intent: 'openspec-change',
+        pipelineIndex: 0,
+        currentAgent: 'task-analyst',
+        phase: 'executing',
+        state: 'completed',
+        activeAttempts: {
+          [analystAttemptId]: {
+            agent: 'task-analyst',
+            stepIndex: 0,
+            attempt: 1,
+            startedAt: todayIso,
+            parallelGroupId: null,
+          },
+        },
+        metricsRunId: runId,
+      },
+      {
+        schemaVersion: 1,
+        task: { runId, slug: 'openspec-handoff', preset: 'ai-rules', stack: 'test', platform, intent: 'openspec-change', profile: 'standard' },
+        events: [
+          { eventId: `${runId}:task_started`, type: 'task_started', at: todayIso },
+          { eventId: `${runId}:analyst-start`, type: 'attempt_started', attemptId: analystAttemptId, agent: 'task-analyst', stepIndex: 0, attempt: 1, at: todayIso },
+        ],
+      },
+    );
+
+    const handoffRaw = invokeHook(hook, root, analystAttemptId);
+    const handoff = JSON.parse(handoffRaw).followup_message;
+    assert.match(handoff, /openspec-author/, `${hook}: handoff did not mention openspec-author`);
+    assert.match(handoff, /openspec:MEDCARD-11762/, `${hook}: handoff did not echo the openspec scope`);
+
+    const statusAfter = readJson(path.join(taskDirectory, 'status.json'));
+    assert.equal(statusAfter.pipelineIndex, 1, `${hook}: hook did not advance past the analyst step`);
+    assert.equal(statusAfter.currentAgent, 'openspec-author', `${hook}: next agent was not openspec-author`);
+    const activeAttempts = Object.values(statusAfter.activeAttempts || {});
+    assert.ok(activeAttempts.some((entry) => entry.agent === 'openspec-author'), `${hook}: openspec-author attempt was not activated`);
+
+    // Now finish the openspec-author attempt with a properly bound receipt
+    // (id: openspec-change) and assert the hook advances to the next step.
+    const openspecAttempt = Object.entries(statusAfter.activeAttempts).find(([, entry]) => entry.agent === 'openspec-author');
+    const openspecAttemptId = openspecAttempt[0];
+    // Use a timestamp after the attempt's actual startedAt — the hook filters
+    // out manifest receipts whose completedAt predates the attempt's start.
+    const freshIso = new Date().toISOString();
+    fs.writeFileSync(
+      path.join(taskDirectory, 'artifact-manifest.json'),
+      JSON.stringify(
+        {
+          schemaVersion: 1,
+          slug: 'openspec-handoff',
+          updatedAt: freshIso,
+          artifacts: [
+            {
+              id: 'openspec-change',
+              producer: 'openspec-author',
+              status: 'completed',
+              authoritativePaths: ['openspec/changes/MEDCARD-11762/proposal.md'],
+              acceptanceCriteriaIds: ['AC-1'],
+              taskIds: ['T1'],
+              timestamps: { createdAt: freshIso, updatedAt: freshIso, completedAt: freshIso },
+              receipt: {
+                outcome: 'completed',
+                attemptId: openspecAttemptId,
+                summary: 'Proposal + design + tasks emitted; openspec validate --strict PASS',
+                evidencePaths: ['openspec/changes/MEDCARD-11762/proposal.md'],
+              },
+            },
+          ],
+        },
+        null,
+        2,
+      ) + '\n',
+    );
+    writeJson(path.join(taskDirectory, 'status.json'), { ...statusAfter, state: 'completed' });
+    const finishRaw = invokeHook(hook, root, openspecAttemptId);
+    const finishHandoff = JSON.parse(finishRaw).followup_message;
+    assert.match(finishHandoff, /Pipeline complete/, `${hook}: pipeline should complete after openspec-author finishes`);
+    const finalStatus = readJson(path.join(taskDirectory, 'status.json'));
+    assert.equal(finalStatus.phase, 'done', `${hook}: phase did not transition to done`);
+    assert.equal(finalStatus.state, 'completed', `${hook}: state did not reach completed after openspec-author`);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Test 2 — qa-tester + unit-test-* handoff: a QA step in a pipeline must
+// advance. Before the fix, DEFAULT_ARTIFACT_OUTPUT_IDS lacked the QA entries
+// so `artifactOutputIdFor` returned the agent name itself; manifest receipts
+// landed under the right id (qa / unit-test-spec) and the hook stalled in
+// awaiting_artifact_receipt.
+// ---------------------------------------------------------------------------
+for (const hook of hooks) {
+  const root = fs.mkdtempSync(path.join(packageDirectory, '.qa-tester-handoff-'));
+  try {
+    const platform = platformFor(hook);
+    const runId = 'qa-tester-run';
+    const devAttemptId = `${runId}:step-0:feature-developer:attempt-1`;
+    const { taskDirectory } = writeTask(
+      root,
+      hook,
+      'qa-tester-handoff',
+      {
+        intent: 'test-only',
+        profile: 'standard',
+        steps: [
+          { agent: 'feature-developer', label: 'Implement' },
+          { agent: 'qa-tester', label: 'QA' },
+        ],
+        humanGates: [],
+      },
+      {
+        slug: 'qa-tester-handoff',
+        intent: 'test-only',
+        pipelineIndex: 0,
+        currentAgent: 'feature-developer',
+        phase: 'executing',
+        state: 'completed',
+        activeAttempts: {
+          [devAttemptId]: {
+            agent: 'feature-developer',
+            stepIndex: 0,
+            attempt: 1,
+            startedAt: todayIso,
+            parallelGroupId: null,
+          },
+        },
+        metricsRunId: runId,
+      },
+      {
+        schemaVersion: 1,
+        task: { runId, slug: 'qa-tester-handoff', preset: 'ai-rules', stack: 'test', platform, intent: 'test-only', profile: 'standard' },
+        events: [
+          { eventId: `${runId}:task_started`, type: 'task_started', at: todayIso },
+          { eventId: `${runId}:dev-start`, type: 'attempt_started', attemptId: devAttemptId, agent: 'feature-developer', stepIndex: 0, attempt: 1, at: todayIso },
+        ],
+      },
+    );
+    const handoff = JSON.parse(invokeHook(hook, root, devAttemptId)).followup_message;
+    assert.match(handoff, /qa-tester/, `${hook}: handoff did not mention qa-tester`);
+    const statusAfter = readJson(path.join(taskDirectory, 'status.json'));
+    assert.equal(statusAfter.pipelineIndex, 1, `${hook}: hook did not advance to qa-tester step`);
+    assert.equal(statusAfter.currentAgent, 'qa-tester', `${hook}: currentAgent was not qa-tester`);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Test 3 — pipeline.json parse error with intent: the hook must surface the
+// error and write state: blocked; legacyFlow must NOT be silently used.
+// ---------------------------------------------------------------------------
+for (const hook of hooks) {
+  const root = fs.mkdtempSync(path.join(packageDirectory, '.pipeline-misparse-'));
+  try {
+    const platform = platformFor(hook);
+    const runId = 'misparse-run';
+    const devAttemptId = `${runId}:step-0:feature-developer:attempt-1`;
+    const taskDirectory = path.join(root, `.${platform}`, 'team', 'tasks', 'misparse');
+    fs.mkdirSync(taskDirectory, { recursive: true });
+    fs.writeFileSync(path.join(root, `.${platform}`, 'team', 'active-task.json'), JSON.stringify({ slug: 'misparse' }));
+    // Malformed pipeline.json with `intent` field — must NOT fall back to legacy.
+    fs.writeFileSync(
+      path.join(taskDirectory, 'pipeline.json'),
+      '{ "intent": "openspec-change", "steps": [\n  { "agent": "openspec-author" }\n', // truncated JSON
+    );
+    writeJson(path.join(taskDirectory, 'status.json'), {
+      slug: 'misparse',
+      intent: 'openspec-change',
+      pipelineIndex: 0,
+      currentAgent: 'feature-developer',
+      phase: 'executing',
+      state: 'completed',
+      activeAttempts: {
+        [devAttemptId]: {
+          agent: 'feature-developer',
+          stepIndex: 0,
+          attempt: 1,
+          startedAt: todayIso,
+          parallelGroupId: null,
+        },
+      },
+      metricsRunId: runId,
+    });
+    writeJson(path.join(taskDirectory, 'metrics.json'), {
+      schemaVersion: 1,
+      task: { runId, slug: 'misparse', preset: 'ai-rules', stack: 'test', platform, intent: 'openspec-change', profile: 'standard' },
+      events: [
+        { eventId: `${runId}:task_started`, type: 'task_started', at: todayIso },
+        { eventId: `${runId}:start`, type: 'attempt_started', attemptId: devAttemptId, agent: 'feature-developer', stepIndex: 0, attempt: 1, at: todayIso },
+      ],
+    });
+
+    const raw = invokeHook(hook, root, devAttemptId);
+    const parsed = JSON.parse(raw);
+    const followup = parsed.followup_message || '';
+    assert.match(followup, /pipeline\.json is malformed/, `${hook}: hook did not surface parse error in followup_message (got: ${followup})`);
+    const status = readJson(path.join(taskDirectory, 'status.json'));
+    assert.equal(status.state, 'blocked', `${hook}: malformed pipeline with intent did not block the pipeline (got: ${status.state})`);
+    assert.equal(status.phase, 'blocked', `${hook}: phase did not transition to blocked`);
+    const metrics = readJson(path.join(taskDirectory, 'metrics.json'));
+    assert.ok(
+      metrics.events.some((event) => event.type === 'pipeline_parse_error'),
+      `${hook}: pipeline_parse_error metric event was not emitted`,
+    );
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Test 4 — legacyFlow fallback: when pipeline.json is absent, the hook must
+// continue to use legacyFlow (analysis → development → review → testing).
+// ---------------------------------------------------------------------------
+for (const hook of hooks) {
+  const root = fs.mkdtempSync(path.join(packageDirectory, '.legacy-fallback-'));
+  try {
+    const platform = platformFor(hook);
+    const taskDirectory = path.join(root, `.${platform}`, 'team', 'tasks', 'legacy-slug');
+    fs.mkdirSync(taskDirectory, { recursive: true });
+    fs.writeFileSync(path.join(root, `.${platform}`, 'team', 'active-task.json'), JSON.stringify({ slug: 'legacy-slug' }));
+    // No pipeline.json — legacy flow triggers.
+    writeJson(path.join(taskDirectory, 'status.json'), {
+      slug: 'legacy-slug',
+      intent: 'feature',
+      phase: 'development',
+      state: 'completed',
+      currentAgent: 'feature-developer',
+      pipelineIndex: 0,
+    });
+    const raw = invokeHook(hook, root, null);
+    const parsed = JSON.parse(raw);
+    const followup = parsed.followup_message || '';
+    assert.match(followup, /build-verifier/, `${hook}: legacy fallback did not invoke build-verifier (got: ${followup})`);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Test 5 — writeStatus durability: after the hook returns, the new
+// status.json must already be on disk and reflect the post-step state. This
+// is the property that lets the orchestrator's next read see the human-gate
+// transition (no stale-read race).
+// ---------------------------------------------------------------------------
+for (const hook of HOOKS_WITH_OPENSPEC) {
+  const root = fs.mkdtempSync(path.join(packageDirectory, '.write-status-durability-'));
+  try {
+    const runId = 'durability-run';
+    const platform = platformFor(hook);
+    const analystAttemptId = `${runId}:step-0:task-analyst:attempt-1`;
+    const { taskDirectory } = writeTask(
+      root,
+      hook,
+      'durability-slug',
+      {
+        intent: 'feature',
+        profile: 'standard',
+        steps: [
+          { agent: 'task-analyst', label: 'Analyze' },
+          { agent: 'openspec-author', label: 'Spec change' },
+        ],
+        humanGates: ['after:task-analyst'],
+      },
+      {
+        slug: 'durability-slug',
+        intent: 'feature',
+        pipelineIndex: 0,
+        currentAgent: 'task-analyst',
+        phase: 'executing',
+        state: 'completed',
+        activeAttempts: {
+          [analystAttemptId]: {
+            agent: 'task-analyst',
+            stepIndex: 0,
+            attempt: 1,
+            startedAt: todayIso,
+            parallelGroupId: null,
+          },
+        },
+        metricsRunId: runId,
+      },
+      {
+        schemaVersion: 1,
+        task: { runId, slug: 'durability-slug', 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: analystAttemptId, agent: 'task-analyst', stepIndex: 0, attempt: 1, at: todayIso },
+        ],
+      },
+    );
+    // Sync + invoke hook; immediately read status.json without fsync of our own.
+    invokeHook(hook, root, analystAttemptId);
+    const onDisk = JSON.parse(fs.readFileSync(path.join(taskDirectory, 'status.json'), 'utf8'));
+    assert.equal(onDisk.awaitingHumanGate, true, `${hook}: human gate was not durably written to status.json`);
+    assert.equal(onDisk.state, 'awaiting_approval', `${hook}: state did not durably transition to awaiting_approval`);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+}
+
+// ---------------------------------------------------------------------------
+// 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');

package/presets/claude/android-kotlin/commands/feature-continue.md

@@ -1,23 +0,0 @@
----
-name: feature-continue
-description: Legacy alias for /task-continue that resumes a feature pipeline after human approval or pause.
----
-
-# Feature continue — legacy alias
-
-> **Prefer:** `/task-continue <slug>` — same behavior, respects `pipeline.json`.
-
-Continue after a human gate. Full logic is in **`task-continue.md`**.
-
-## Short version
-
-1. Read `pipeline.json` (if present) and `status.json`.
-2. Clear `awaitingHumanGate`; determine the next step from `pipelineIndex`.
-3. Invoke the subagent for `currentAgent`.
-4. The hook continues the chain when `autoChain: true`.
-
-See `task-continue.md` for details and the handoff table.
-
-## Product specs (docs/specs)
-
-When the next agent is **feature-developer** (or other implementer): if `docs/specs/INDEX.md` exists, instruct them to load **`product-specs`** and honor **Related specs** from `brief.md` (behavior SoT). Soft-fail on miss; never invent product behavior. No-op if INDEX is absent.

package/presets/claude/android-kotlin/commands/feature-start.md

@@ -1,41 +0,0 @@
----
-name: feature-start
-description: Legacy analyst-only feature intake. Prefer /task for new work because it uses router and dynamic pipeline.
----
-
-# Feature start — legacy (analyst only)
-
-> **Prefer:** `/task <description>` — the router chooses roles and order automatically.
-
-Starts the **analysis phase** without the router. The parent agent acts as orchestrator (see `tooling-and-review/agent-team-orchestrator.md`).
-
-## What to do
-
-1. Extract the task description from the command arguments (everything after `/feature-start`).
-2. Generate a **slug** (kebab-case, up to 48 characters) from the task title.
-3. Create `.claude/team/tasks/<slug>/` if it does not exist yet — via **Write** of an artifact (not Shell `mkdir`).
-4. Write `.claude/team/active-task.json` → `{ "slug": "<slug>" }`.
-5. Optional: minimal `pipeline.json` with fixed steps (analyst → developer → reviewer → qa-tester).
-6. Invoke subagent **task-analyst** (Task tool) with the full task description and artifact paths.
-7. Wait for the analyst to finish. **Do not invoke developer** at this stage.
-
-## Product specs (docs/specs)
-
-When invoking **task-analyst**: if `docs/specs/INDEX.md` exists, instruct consume via **`product-specs`** and cite **Related specs**. Soft-fail on miss; never invent behavior.
-
-If the user/AC requests generation or bootstrap, or INDEX is missing **with** bootstrap AC / `/spec-start` intent: instruct **author mode** inside the same analyst step — load **`product-specs-authoring`** + skill **`spec-authoring`**. Authoring is **not** a separate pipeline agent. Handoff must list created paths + INDEX diff; human gate must approve generated specs before feature-developer.
-
-
-## Human gate
-
-After the analyst:
-
-- Show the user links to `brief.md` and `decomposition.md`.
-- Also ask them to check **Related specs** in `brief.md` when `docs/specs/INDEX.md` exists.
-- Ask them to review and approve or send edits.
-- To continue: `/task-continue <slug>` or `/feature-continue <slug>`.
-
-## If the slug already exists
-
-- If `status.json` is `awaiting_approval` — offer review or continue.
-- If the task is in progress — ask whether to continue or start a new slug.