@bonesofspring/ai-rules 0.2.25 → 0.2.27

package/scripts/lib/stack-platform-profiles.mjs

@@ -0,0 +1,148 @@
+/**
+ * Per-stack always-on rules and OpenCode edit allow-lists for Mavis/OpenCode derive.
+ */
+const FRONTEND_DEVELOPER_AGENTS = [
+  'feature-developer',
+  'debugger',
+  'ci-investigator',
+  'qa-tester',
+  'unit-test-generator',
+  'unit-test-healer',
+  'playwright-test-generator',
+  'playwright-test-healer',
+];
+
+const MOBILE_DEVELOPER_BASE = [
+  'feature-developer',
+  'debugger',
+  'ci-investigator',
+  'qa-tester',
+  'unit-test-generator',
+  'unit-test-healer',
+];
+
+const BACKEND_DEVELOPER_AGENTS = [
+  'feature-developer',
+  'debugger',
+  'ci-investigator',
+  'qa-tester',
+  'unit-test-generator',
+  'unit-test-healer',
+  'integration-test-generator',
+  'integration-test-healer',
+];
+
+const QUALITY_OVERLAY = ['code-quality-and-refactoring', 'ai-local-overlay'];
+
+/** @typedef {{ title: string, family: string, alwaysOn: string[], developerAgents: string[] }} StackProfile */
+
+/** @type {Record<string, StackProfile>} */
+export const STACK_PROFILES = {
+  next: {
+    title: 'Next.js',
+    family: 'frontend',
+    alwaysOn: ['next-app-core', 'package-manager', ...QUALITY_OVERLAY],
+    developerAgents: FRONTEND_DEVELOPER_AGENTS,
+  },
+  nuxt: {
+    title: 'Nuxt 3',
+    family: 'frontend',
+    alwaysOn: ['nuxt-app-core', 'package-manager', ...QUALITY_OVERLAY],
+    developerAgents: FRONTEND_DEVELOPER_AGENTS,
+  },
+  svelte: {
+    title: 'SvelteKit',
+    family: 'frontend',
+    alwaysOn: ['svelte-app-core', 'package-manager', ...QUALITY_OVERLAY],
+    developerAgents: FRONTEND_DEVELOPER_AGENTS,
+  },
+  'ios-swift': {
+    title: 'iOS Swift',
+    family: 'ios',
+    alwaysOn: ['ios-app-core', 'architecture-boundaries', ...QUALITY_OVERLAY],
+    developerAgents: [
+      ...MOBILE_DEVELOPER_BASE,
+      'xcuitest-test-generator',
+      'xcuitest-test-healer',
+    ],
+  },
+  'android-kotlin': {
+    title: 'Android Kotlin',
+    family: 'android',
+    alwaysOn: ['android-app-core', 'architecture-boundaries', ...QUALITY_OVERLAY],
+    developerAgents: [
+      ...MOBILE_DEVELOPER_BASE,
+      'instrumentation-test-generator',
+      'instrumentation-test-healer',
+    ],
+  },
+  go: {
+    title: 'Go hexagonal',
+    family: 'backend',
+    alwaysOn: ['go-app-core', 'architecture-boundaries', ...QUALITY_OVERLAY],
+    developerAgents: BACKEND_DEVELOPER_AGENTS,
+  },
+  java: {
+    title: 'Java hexagonal',
+    family: 'backend',
+    alwaysOn: ['java-app-core', 'architecture-boundaries', ...QUALITY_OVERLAY],
+    developerAgents: BACKEND_DEVELOPER_AGENTS,
+  },
+  'php-hexagonal': {
+    title: 'PHP hexagonal',
+    family: 'backend',
+    alwaysOn: ['php-app-core', 'architecture-boundaries', ...QUALITY_OVERLAY],
+    developerAgents: BACKEND_DEVELOPER_AGENTS,
+  },
+  'php-laravel': {
+    title: 'Laravel',
+    family: 'backend',
+    alwaysOn: ['laravel-app-core', 'architecture-boundaries', ...QUALITY_OVERLAY],
+    developerAgents: BACKEND_DEVELOPER_AGENTS,
+  },
+  'mcp-ts': {
+    title: 'TypeScript MCP',
+    family: 'mcp-ts',
+    alwaysOn: ['mcp-ts-app-core', 'mcp-server-boundaries', ...QUALITY_OVERLAY],
+    developerAgents: ['feature-developer'],
+  },
+};
+
+export const REVIEW_AGENTS = new Set(['code-reviewer']);
+
+/** Extra OpenCode permission.edit allow globs for roles that write outside the team root. */
+export const AGENT_WRITE_SCOPES = {
+  'openspec-author': ['openspec/**'],
+  'tech-writer': ['docs/**'],
+};
+
+export function getStackProfile(stack) {
+  const profile = STACK_PROFILES[stack];
+  if (!profile) {
+    throw new Error(
+      `unknown stack "${stack}". Known: ${Object.keys(STACK_PROFILES).join(', ')}`,
+    );
+  }
+  return profile;
+}
+
+export function parseStackArg(argv, { required = true } = {}) {
+  let stack;
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === '--stack') {
+      stack = argv[index + 1];
+      index += 1;
+    } else {
+      throw new Error(`unknown argument: ${arg}`);
+    }
+  }
+  if (!stack) {
+    if (required) {
+      throw new Error('Missing --stack <name> (e.g. --stack nuxt)');
+    }
+    return undefined;
+  }
+  getStackProfile(stack);
+  return stack;
+}

package/scripts/sync-dogfood-cursor.sh

@@ -33,7 +33,7 @@ if [[ -f "$SRC/REPO_AGENTS.md" ]]; then
   echo "Copied REPO_AGENTS.md → $ROOT/AGENTS.md"
 fi
 
-# Directory trees (preserve local team/tasks)
+# Directory trees (team runtime lives in .ai.local/team)
 for dir in agents commands hooks rules skills; do
   if [[ -d "$SRC/$dir" ]]; then
     mkdir -p "$DST/$dir"
@@ -41,30 +41,10 @@ for dir in agents commands hooks rules skills; do
   fi
 done
 
-if [[ -d "$SRC/team" ]]; then
-  mkdir -p "$DST/team"
-  # Sync fixtures + README; never delete local tasks/
-  if [[ -d "$SRC/team/fixtures" ]]; then
-    mkdir -p "$DST/team/fixtures"
-    rsync -a --delete "$SRC/team/fixtures/" "$DST/team/fixtures/"
-  fi
-  if [[ -f "$SRC/team/README.md" ]]; then
-    cp "$SRC/team/README.md" "$DST/team/README.md"
-  fi
-  if [[ -f "$SRC/team/.gitkeep" ]]; then
-    mkdir -p "$DST/team/tasks"
-    cp "$SRC/team/.gitkeep" "$DST/team/tasks/.gitkeep" 2>/dev/null || true
-  fi
-  # Living conventions: seed if absent; preserve consumer edits
-  if [[ -f "$SRC/team/conventions.md" ]]; then
-    if [[ ! -f "$DST/team/conventions.md" ]]; then
-      cp "$SRC/team/conventions.md" "$DST/team/conventions.md"
-      echo "Seeded team/conventions.md"
-    else
-      echo "Tip: skipped team/conventions.md (already present — living dogfood notes preserved)"
-    fi
-  fi
-fi
+node -e "
+const { seedAiLocalTeam } = require(process.argv[1]);
+seedAiLocalTeam({ cwd: process.argv[2], presetTeamSrc: process.argv[3] });
+" "$ROOT/packages/ai-rules/bin/lib/seed-ai-local-team.js" "$ROOT" "$SRC/team"
 
-echo "Done. Review: git status -- .cursor/ AGENTS.md"
+echo "Done. Review: git status -- .cursor/ AGENTS.md .ai.local/team"
 echo "Tip: run packages/ai-rules/scripts/check-shared-core-drift.sh after core edits."

package/scripts/sync-dogfood-mavis.sh

@@ -5,9 +5,8 @@
 #   ./packages/ai-rules/scripts/sync-dogfood-mavis.sh
 #   AI_RULES_DOGFOOD_PRESET=next ./packages/ai-rules/scripts/sync-dogfood-mavis.sh
 #
-# Note: `.mavis/` is ai-rules-owned, not a MiniMax-native discovery path. Mavis
-# only ships `next` in `releasedStacks` (see presets/mavis/platform-contract.json).
-# Other stacks stay TBD until WP-F human gate.
+# Note: `.mavis/` is ai-rules-owned, not a MiniMax-native discovery path.
+# This monorepo dogfood stays `next` (do not sync other released stacks here).
 set -euo pipefail
 
 ROOT="$(cd "$(dirname "$0")/../../.." && pwd)"
@@ -32,9 +31,9 @@ for f in MAVIS.md MCP.md mcp.json README.md; do
 done
 
 # `.mavis/AGENTS.md` is the Mavis entry point (mirrors `.cursor/AGENTS.md`).
-if [[ -f "$SRC/MAVIS.md" && ! -f "$DST/AGENTS.md" ]]; then
+if [[ -f "$SRC/MAVIS.md" ]]; then
   cp "$SRC/MAVIS.md" "$DST/AGENTS.md"
-  echo "Seeded .mavis/AGENTS.md from MAVIS.md"
+  echo "Synced .mavis/AGENTS.md from MAVIS.md"
 fi
 
 # Repo-root AGENTS.md (cross-tool) from REPO_AGENTS.md
@@ -43,7 +42,7 @@ if [[ -f "$SRC/REPO_AGENTS.md" ]]; then
   echo "Copied REPO_AGENTS.md → $ROOT/AGENTS.md"
 fi
 
-# Directory trees (preserve local team/tasks)
+# Directory trees (team runtime lives in .ai.local/team)
 for dir in agents commands rules skills; do
   if [[ -d "$SRC/$dir" ]]; then
     mkdir -p "$DST/$dir"
@@ -61,30 +60,10 @@ if [[ -d "$SRC/hooks" ]]; then
   fi
 fi
 
-if [[ -d "$SRC/team" ]]; then
-  mkdir -p "$DST/team"
-  # Sync fixtures + README; never delete local tasks/
-  if [[ -d "$SRC/team/fixtures" ]]; then
-    mkdir -p "$DST/team/fixtures"
-    rsync -a --delete "$SRC/team/fixtures/" "$DST/team/fixtures/"
-  fi
-  if [[ -f "$SRC/team/README.md" ]]; then
-    cp "$SRC/team/README.md" "$DST/team/README.md"
-  fi
-  if [[ -f "$SRC/team/.gitkeep" ]]; then
-    mkdir -p "$DST/team/tasks"
-    cp "$SRC/team/.gitkeep" "$DST/team/tasks/.gitkeep" 2>/dev/null || true
-  fi
-  # Living conventions: seed if absent; preserve consumer edits
-  if [[ -f "$SRC/team/conventions.md" ]]; then
-    if [[ ! -f "$DST/team/conventions.md" ]]; then
-      cp "$SRC/team/conventions.md" "$DST/team/conventions.md"
-      echo "Seeded team/conventions.md"
-    else
-      echo "Tip: skipped team/conventions.md (already present — living dogfood notes preserved)"
-    fi
-  fi
-fi
+node -e "
+const { seedAiLocalTeam } = require(process.argv[1]);
+seedAiLocalTeam({ cwd: process.argv[2], presetTeamSrc: process.argv[3] });
+" "$ROOT/packages/ai-rules/bin/lib/seed-ai-local-team.js" "$ROOT" "$SRC/team"
 
-echo "Done. Review: git status -- .mavis/ AGENTS.md"
+echo "Done. Review: git status -- .mavis/ AGENTS.md .ai.local/team"
 echo "Tip: run packages/ai-rules/scripts/check-shared-core-drift.sh after core edits."

package/scripts/sync-dogfood-opencode.sh

@@ -5,7 +5,7 @@
 #   ./packages/ai-rules/scripts/sync-dogfood-opencode.sh
 #   AI_RULES_DOGFOOD_PRESET=next ./packages/ai-rules/scripts/sync-dogfood-opencode.sh
 #
-# Note: OpenCode only ships `next` in `releasedStacks`.
+# Note: this monorepo dogfood stays `next` (do not sync other released stacks here).
 set -euo pipefail
 
 ROOT="$(cd "$(dirname "$0")/../../.." && pwd)"
@@ -58,28 +58,10 @@ if [[ -d "$SRC/hooks" ]]; then
   fi
 fi
 
-if [[ -d "$SRC/team" ]]; then
-  mkdir -p "$DST/team"
-  if [[ -d "$SRC/team/fixtures" ]]; then
-    mkdir -p "$DST/team/fixtures"
-    rsync -a --delete "$SRC/team/fixtures/" "$DST/team/fixtures/"
-  fi
-  if [[ -f "$SRC/team/README.md" ]]; then
-    cp "$SRC/team/README.md" "$DST/team/README.md"
-  fi
-  if [[ -f "$SRC/team/.gitkeep" ]]; then
-    mkdir -p "$DST/team/tasks"
-    cp "$SRC/team/.gitkeep" "$DST/team/tasks/.gitkeep" 2>/dev/null || true
-  fi
-  if [[ -f "$SRC/team/conventions.md" ]]; then
-    if [[ ! -f "$DST/team/conventions.md" ]]; then
-      cp "$SRC/team/conventions.md" "$DST/team/conventions.md"
-      echo "Seeded team/conventions.md"
-    else
-      echo "Tip: skipped team/conventions.md (already present — living dogfood notes preserved)"
-    fi
-  fi
-fi
+node -e "
+const { seedAiLocalTeam } = require(process.argv[1]);
+seedAiLocalTeam({ cwd: process.argv[2], presetTeamSrc: process.argv[3] });
+" "$ROOT/packages/ai-rules/bin/lib/seed-ai-local-team.js" "$ROOT" "$SRC/team"
 
-echo "Done. Review: git status -- .opencode/ AGENTS.md opencode.json"
+echo "Done. Review: git status -- .opencode/ AGENTS.md opencode.json .ai.local/team"
 echo "Tip: run packages/ai-rules/scripts/check-shared-core-drift.sh after core edits."

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

@@ -59,7 +59,7 @@ function invokeHookAsync(hook, workingDirectory, attemptId) {
 
 function writeTask(root, hook, slug, pipeline, status, metrics, artifacts = {}) {
   const platform = platformFromHook(hook);
-  const teamRoot = path.join(root, `.${platform}`, 'team');
+  const teamRoot = path.join(root, '.ai.local', 'team');
   const taskDirectory = path.join(teamRoot, 'tasks', slug);
   fs.mkdirSync(taskDirectory, { recursive: true });
   writeJson(path.join(teamRoot, 'active-task.json'), { slug });
@@ -72,9 +72,20 @@ function writeTask(root, hook, slug, pipeline, status, metrics, artifacts = {})
   return taskDirectory;
 }
 
+function setupTaskWithoutMetrics(root, hook, slug, pipeline, status) {
+  const platform = platformFromHook(hook);
+  const teamRoot = path.join(root, '.ai.local', '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);
+  return taskDirectory;
+}
+
 function prepareTask(root, hook) {
   const platform = platformFromHook(hook);
-  const teamRoot = path.join(root, `.${platform}`, 'team');
+  const teamRoot = path.join(root, '.ai.local', 'team');
   const taskDirectory = path.join(teamRoot, 'tasks', 'reverse-parallel');
   fs.mkdirSync(taskDirectory, { recursive: true });
   writeJson(path.join(teamRoot, 'active-task.json'), { slug: 'reverse-parallel' });
@@ -458,7 +469,7 @@ for (const hook of hooks) {
     assert.match(commandSource, /single authority/);
     assert.match(commandSource, /\*\*Do not\*\* manually increment/);
 
-    const teamRoot = path.join(root, `.${platform}`, 'team');
+    const teamRoot = path.join(root, '.ai.local', 'team');
     const taskDirectory = path.join(teamRoot, 'tasks', 'gate-resume');
     fs.mkdirSync(taskDirectory, { recursive: true });
     const runId = 'gate-resume-run';
@@ -983,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,
@@ -999,4 +1010,49 @@ for (const hook of hooks) {
   }
 }
 
-console.log(`Verified retry, parallel, skip, gate, manifest-reconcile, lock-race, and aggregation lifecycle in ${hooks.length} hooks.`);
+for (const hook of hooks) {
+  const root = fs.mkdtempSync(path.join(packageDirectory, '.agent-task-metrics-hook-init-platform-'));
+  try {
+    const platform = platformFromHook(hook);
+    const runId = 'hook-init-platform-run';
+    const attemptId = `${runId}:step-0:feature-developer:attempt-1`;
+    const taskDirectory = setupTaskWithoutMetrics(
+      root,
+      hook,
+      'hook-init-platform',
+      {
+        autoChain: false,
+        steps: [{ agent: 'feature-developer' }],
+      },
+      {
+        slug: 'hook-init-platform',
+        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,
+      },
+    );
+    invokeHook(hook, root, attemptId);
+    const metrics = readJson(path.join(taskDirectory, 'metrics.json'));
+    assert.equal(
+      metrics.task.platform,
+      platform,
+      `${hook}: hook-created metrics.task.platform must equal ${platform}`,
+    );
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+}
+
+console.log(`Verified retry, parallel, skip, gate, manifest-reconcile, lock-race, hook-init platform, and aggregation lifecycle in ${hooks.length} hooks.`);

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

@@ -73,7 +73,7 @@ function platformFor(hook) {
 
 function writeTask(root, hook, slug, pipeline, status, metrics, artifacts = {}) {
   const platform = platformFor(hook);
-  const teamRoot = path.join(root, `.${platform}`, 'team');
+  const teamRoot = path.join(root, '.ai.local', 'team');
   const taskDirectory = path.join(teamRoot, 'tasks', slug);
   fs.mkdirSync(taskDirectory, { recursive: true });
   writeJson(path.join(teamRoot, 'active-task.json'), { slug });
@@ -273,9 +273,9 @@ for (const hook of hooks) {
     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');
+    const taskDirectory = path.join(root, '.ai.local', 'team', 'tasks', 'misparse');
     fs.mkdirSync(taskDirectory, { recursive: true });
-    fs.writeFileSync(path.join(root, `.${platform}`, 'team', 'active-task.json'), JSON.stringify({ slug: 'misparse' }));
+    fs.writeFileSync(path.join(root, '.ai.local', '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'),
@@ -333,9 +333,9 @@ 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');
+    const taskDirectory = path.join(root, '.ai.local', 'team', 'tasks', 'legacy-slug');
     fs.mkdirSync(taskDirectory, { recursive: true });
-    fs.writeFileSync(path.join(root, `.${platform}`, 'team', 'active-task.json'), JSON.stringify({ slug: 'legacy-slug' }));
+    fs.writeFileSync(path.join(root, '.ai.local', 'team', 'active-task.json'), JSON.stringify({ slug: 'legacy-slug' }));
     // No pipeline.json — legacy flow triggers.
     writeJson(path.join(taskDirectory, 'status.json'), {
       slug: 'legacy-slug',
@@ -498,7 +498,7 @@ for (const hook of hooks) {
       },
     );
 
-    const taskDirectory = path.join(root, `.${platform}`, 'team', 'tasks', 'stale-attempt-id');
+    const taskDirectory = path.join(root, '.ai.local', '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'));
@@ -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.`);