@bonesofspring/ai-rules 0.2.11 → 0.2.12

package/presets/cursor/mcp-ts/hooks/chain-team-phases.sh

@@ -52,6 +52,8 @@ if (!slug) {
 const taskDir = path.join(TEAM_ROOT, 'tasks', slug);
 const statusPath = path.join(taskDir, 'status.json');
 const pipelinePath = path.join(taskDir, 'pipeline.json');
+const METRICS_PATH = path.join(taskDir, 'metrics.json');
+const METRICS_LOCK = `${METRICS_PATH}.lock`;
 
 if (!fs.existsSync(statusPath)) {
   process.stdout.write('{}');
@@ -59,18 +61,119 @@ if (!fs.existsSync(statusPath)) {
 }
 
 let status;
+const now = new Date().toISOString();
+const STACK = 'mcp-ts';
+const PLATFORM = 'cursor';
+
+function waitForMetricsLock() {
+  for (let attempt = 0; attempt < 200; attempt += 1) {
+    try { fs.mkdirSync(METRICS_LOCK); return; } catch (error) {
+      if (error && error.code !== 'EEXIST') throw error;
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 10);
+    }
+  }
+  throw new Error('metrics lock timeout');
+}
+let taskLockHeld = false;
+function releaseTaskLock() {
+  if (!taskLockHeld) return;
+  taskLockHeld = false;
+  try { fs.rmdirSync(METRICS_LOCK); } catch {}
+}
+waitForMetricsLock();
+taskLockHeld = true;
+process.on('exit', releaseTaskLock);
 try {
   status = JSON.parse(fs.readFileSync(statusPath, 'utf8'));
 } catch {
+  releaseTaskLock();
   process.stdout.write('{}');
   process.exit(0);
 }
+function mutateMetrics(mutator) {
+  const acquiredHere = !taskLockHeld;
+  if (acquiredHere) waitForMetricsLock();
+  try {
+    let metrics;
+    try { metrics = JSON.parse(fs.readFileSync(METRICS_PATH, 'utf8')); } catch {
+      const runId = status.metricsRunId || `${slug}-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+      status.metricsRunId = runId;
+      metrics = { schemaVersion: 1, task: { runId, slug, preset: 'ai-rules', stack: STACK, platform: PLATFORM, intent: status.intent || 'unknown', profile: 'unknown' }, events: [] };
+      metrics.events.push({ eventId: `${runId}:task_started`, type: 'task_started', at: now, source: 'hook', attributionConfidence: 'high' });
+    }
+    mutator(metrics);
+    const temporary = `${METRICS_PATH}.${process.pid}.${Date.now()}.tmp`;
+    fs.writeFileSync(temporary, JSON.stringify(metrics, null, 2) + '\n');
+    fs.renameSync(temporary, METRICS_PATH);
+  } finally {
+    if (acquiredHere) { try { fs.rmdirSync(METRICS_LOCK); } catch {} }
+  }
+}
+function appendMetric(event) { mutateMetrics((metrics) => metrics.events.push({ eventId: `${metrics.task.runId}:${Date.now()}:${Math.random().toString(16).slice(2)}`, ...event })); }
+function nextAttemptOrdinal(stepIndex, agent) {
+  try {
+    const metrics = JSON.parse(fs.readFileSync(METRICS_PATH, 'utf8'));
+    return metrics.events.reduce((highest, event) => event.type === 'attempt_started' && event.stepIndex === stepIndex && event.agent === agent ? Math.max(highest, Number(event.attempt) || 0) : highest, 0) + 1;
+  } catch { return 1; }
+}
+function roleFor(agent) {
+  if (/analyst|architect|router|migration/.test(agent || '')) return 'planning';
+  if (/verifier/.test(agent || '')) return 'validation';
+  if (/reviewer|auditor/.test(agent || '')) return 'review';
+  if (/test|qa/.test(agent || '')) return 'testing';
+  if (/writer/.test(agent || '')) return 'docs';
+  return 'implementation';
+}
+function activateAttempts(step, stepIndex) {
+  const active = { ...(status.activeAttempts || {}) }; const agents = getStepAgents(step);
+  const parallelGroupId = step.parallel && agents.length > 1 ? `${status.metricsRunId || slug}:step-${stepIndex}` : null;
+  for (const agent of agents) {
+    const attempt = nextAttemptOrdinal(stepIndex, agent); const runId = status.metricsRunId || `${slug}-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+    status.metricsRunId = runId; const attemptId = `${runId}:step-${stepIndex}:${agent}:attempt-${attempt}`;
+    if (active[attemptId]) continue;
+    active[attemptId] = { agent, stepIndex, attempt, startedAt: now, parallelGroupId };
+    appendMetric({ type: 'attempt_started', at: now, attemptId, stepIndex, stepLabel: step.label || null, agent, role: roleFor(agent), attempt, parallelGroupId, source: 'hook', attributionConfidence: 'high' });
+  }
+  status.activeAttempts = active;
+}
+function resolvedAttempt() {
+  const active = status.activeAttempts || {}; const entries = Object.entries(active);
+  const stableAttemptId = hookInput.attemptId;
+  if (stableAttemptId) {
+    return active[stableAttemptId] ? { attemptId: stableAttemptId, entry: active[stableAttemptId], confidence: 'high' } : null;
+  }
+  if (entries.length === 1) return { attemptId: entries[0][0], entry: entries[0][1], confidence: 'high' };
+  try { const receipts = JSON.parse(fs.readFileSync(path.join(taskDir, '.metrics-receipts.json'), 'utf8')); const receipt = Array.isArray(receipts) ? receipts.find((item) => active[item.attemptId]) : null; if (receipt) return { attemptId: receipt.attemptId, entry: active[receipt.attemptId], confidence: 'fallback', source: 'agent' }; } catch {}
+  return null;
+}
+function finishActiveAttempt() {
+  const resolved = resolvedAttempt(); if (!resolved) return null;
+  const durationMs = Date.parse(now) - Date.parse(resolved.entry.startedAt);
+  appendMetric({ type: 'attempt_finished', at: now, attemptId: resolved.attemptId, outcome: ['completed', 'changes_requested', 'validation_failed'].includes(status.state) ? status.state : 'unknown', durationMs: Number.isFinite(durationMs) && durationMs >= 0 ? durationMs : null, retryAfterFix: status.retryAfterFix || null, source: resolved.source || 'hook', attributionConfidence: resolved.confidence });
+  const active = { ...(status.activeAttempts || {}) }; delete active[resolved.attemptId]; status.activeAttempts = active; status.lastCompletedAttempt = { attemptId: resolved.attemptId, completedAt: now }; return resolved;
+}
+function beginHumanGate() { const eventId = `${status.metricsRunId || slug}:gate:${Date.now()}`; appendMetric({ eventId, type: 'human_gate_started', at: now, source: 'hook', attributionConfidence: 'high' }); status.activeHumanGateEventId = eventId; }
+function endHumanGateIfResumed() {
+  if (!status.activeHumanGateEventId || status.awaitingHumanGate || status.state === 'awaiting_approval') return;
+  appendMetric({ type: 'human_gate_ended', at: now, gateStartedEventId: status.activeHumanGateEventId, source: 'hook', attributionConfidence: 'high' });
+  delete status.activeHumanGateEventId;
+}
+function completeTaskMetrics() { appendMetric({ type: 'task_completed', at: now, outcome: status.state === 'completed' ? 'completed' : 'unknown', source: 'hook', attributionConfidence: 'high' }); }
+function recordSkippedStep(step, stepIndex) {
+  for (const agent of getStepAgents(step)) {
+    const runId = status.metricsRunId || `${slug}-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+    status.metricsRunId = runId;
+    const attempt = nextAttemptOrdinal(stepIndex, agent);
+    appendMetric({ type: 'attempt_skipped', at: now, attemptId: `${runId}:step-${stepIndex}:${agent}:attempt-${attempt}`, stepIndex, stepLabel: step.label || null, agent, role: roleFor(agent), attempt, outcome: 'skipped', source: 'hook', attributionConfidence: 'high' });
+  }
+}
 
-const now = new Date().toISOString();
 
 function writeStatus(next) {
   status = { ...status, ...next, slug, updatedAt: now };
-  fs.writeFileSync(statusPath, JSON.stringify(status, null, 2) + '\n');
+  const temporary = `${statusPath}.${process.pid}.${Date.now()}.tmp`;
+  fs.writeFileSync(temporary, JSON.stringify(status, null, 2) + '\n');
+  fs.renameSync(temporary, statusPath);
 }
 
 function out(message) {
@@ -108,9 +211,8 @@ function skipIfMatches(skipIf, dir) {
 
 function findNextExecutableStep(steps, startIdx, dir) {
   for (let i = startIdx; i < steps.length; i++) {
-    if (!skipIfMatches(steps[i].skipIf, dir)) {
-      return { step: steps[i], index: i };
-    }
+    if (!skipIfMatches(steps[i].skipIf, dir)) return { step: steps[i], index: i };
+    recordSkippedStep(steps[i], i);
   }
   return null;
 }
@@ -138,16 +240,29 @@ const REVIEW_AGENTS = new Set([
 ]);
 
 
+function metricsHandoff(agent) {
+  const matches = Object.entries(status.activeAttempts || {}).filter(([, entry]) => entry.agent === agent);
+  if (matches.length === 1) {
+    return ` Metrics attemptId: ${matches[0][0]}; update normal status only. If the hook cannot identify a parallel stop, append a minimal { attemptId, outcome } receipt to .metrics-receipts.json; do not calculate duration.`;
+  }
+  return ' Metrics: use the supplied attemptId when available; for a parallel completion, write a minimal { attemptId, outcome } receipt to .metrics-receipts.json rather than relying on currentAgent. Do not calculate duration.';
+}
+
 function handoffForAgent(agent, scope) {
   const fn = AGENT_HANDOFF[agent];
-  return fn ? fn(slug, scope) : `Invoke ${agent} subagent for slug "${slug}". Update status.json when done.`;
+  const handoff = fn ? fn(slug, scope) : `Invoke ${agent} subagent for slug "${slug}". Update status.json when done.`;
+  return handoff + metricsHandoff(agent);
 }
 
 function handoffForParallelStep(step) {
   const agents = getStepAgents(step);
+  const attemptIds = Object.entries(status.activeAttempts || {})
+    .filter(([, entry]) => agents.includes(entry.agent))
+    .map(([attemptId, entry]) => `${entry.agent}=${attemptId}`);
   return (
     `Invoke IN PARALLEL (one message, multiple Task calls): ${agents.join(' AND ')} for slug "${slug}". ` +
-    `Each agent writes its artifact and appends itself to status.json parallelCompleted when done.`
+    `Each agent writes its artifact and appends itself to status.json parallelCompleted when done. ` +
+    `Metrics attemptIds: ${attemptIds.join('; ')}. If the hook cannot identify a parallel stop, append a minimal { attemptId, outcome } receipt to .metrics-receipts.json; do not calculate duration.`
   );
 }
 
@@ -179,34 +294,38 @@ function legacyFlow() {
     out(`Pipeline complete for "${slug}". Run /technical-retro ${slug}.`);
     process.exit(0);
   }
+  function scheduleLegacyRetry(agent, retryAfterFix) {
+    const stepIndex = typeof status.pipelineIndex === 'number' ? status.pipelineIndex : 0;
+    const predecessorAttemptId = status.lastCompletedAttempt?.attemptId || null;
+    appendMetric({ type: 'retry_scheduled', at: now, attemptId: predecessorAttemptId, nextAgent: agent, retryAfterFix: retryAfterFix || null, source: 'hook', attributionConfidence: 'unknown' });
+    activateAttempts({ agent }, stepIndex);
+  }
   if (status.state === 'changes_requested' && REVIEW_AGENTS.has(status.currentAgent)) {
+    const reviewer = status.currentAgent;
+    scheduleLegacyRetry('feature-developer', reviewer);
     writeStatus({
       currentAgent: 'feature-developer',
       state: 'in_progress',
       phase: 'executing',
-      retryAfterFix: status.currentAgent,
+      retryAfterFix: reviewer,
     });
-    out(
-      handoffForAgent('feature-developer') +
-        ` After fixes, re-run ${status.currentAgent}.`,
-    );
+    out(handoffForAgent('feature-developer') + ` After fixes, re-run ${reviewer}.`);
     process.exit(0);
   }
   if (status.state === 'validation_failed' && status.currentAgent === 'build-verifier') {
+    scheduleLegacyRetry('feature-developer', 'build-verifier');
     writeStatus({
       currentAgent: 'feature-developer',
       state: 'in_progress',
       phase: 'executing',
       retryAfterFix: 'build-verifier',
     });
-    out(
-      handoffForAgent('feature-developer') +
-        ` Read validation-report.md. After fixes, re-run build-verifier.`,
-    );
+    out(handoffForAgent('feature-developer') + ' Read validation-report.md. After fixes, re-run build-verifier.');
     process.exit(0);
   }
   if (status.state === 'completed' && status.retryAfterFix) {
     const retry = status.retryAfterFix;
+    scheduleLegacyRetry(retry, null);
     writeStatus({ currentAgent: retry, state: 'in_progress', retryAfterFix: null });
     out(handoffForAgent(retry));
     process.exit(0);
@@ -220,6 +339,56 @@ function legacyFlow() {
   process.exit(0);
 }
 
+
+if (hookInput.action === 'end_human_gate') {
+  status.awaitingHumanGate = false;
+  if (status.state === 'awaiting_approval') {
+    status.state = 'in_progress';
+    status.phase = status.phase === 'human_gate' ? 'executing' : status.phase;
+  }
+  if (status.activeHumanGateEventId) {
+    appendMetric({
+      type: 'human_gate_ended',
+      at: now,
+      gateStartedEventId: status.activeHumanGateEventId,
+      source: 'orchestrator',
+      attributionConfidence: 'high',
+    });
+    delete status.activeHumanGateEventId;
+  }
+  if (hookInput.activateNext && fs.existsSync(pipelinePath)) {
+    let resumePipeline = null;
+    try { resumePipeline = JSON.parse(fs.readFileSync(pipelinePath, 'utf8')); } catch {}
+    if (resumePipeline) {
+      const resumeSteps = resumePipeline.steps || [];
+      const resumeStart = (typeof status.pipelineIndex === 'number' ? status.pipelineIndex : 0) + 1;
+      const resumeNext = findNextExecutableStep(resumeSteps, resumeStart, taskDir);
+      if (resumeNext) {
+        const resumeAgents = getStepAgents(resumeNext.step);
+        activateAttempts(resumeNext.step, resumeNext.index);
+        writeStatus({
+          pipelineIndex: resumeNext.index,
+          currentAgent: resumeAgents[0],
+          phase: 'executing',
+          state: 'in_progress',
+          awaitingHumanGate: false,
+          parallelCompleted: [],
+        });
+        if (resumeNext.step.parallel && resumeAgents.length > 1) out(handoffForParallelStep(resumeNext.step));
+        else out(handoffForAgent(resumeAgents[0], resumeNext.step.scope));
+        process.exit(0);
+      }
+    }
+  }
+  writeStatus({
+    awaitingHumanGate: false,
+    state: status.state,
+    phase: status.phase,
+  });
+  process.stdout.write(JSON.stringify({ ok: true, action: 'end_human_gate', activeHumanGateEventId: status.activeHumanGateEventId || null }));
+  process.exit(0);
+}
+
 if (!fs.existsSync(pipelinePath)) {
   legacyFlow();
 }
@@ -232,6 +401,15 @@ try {
 }
 
 const steps = pipeline.steps || [];
+const initialIdx = typeof status.pipelineIndex === 'number' ? status.pipelineIndex : 0;
+const initialStep = steps[initialIdx];
+const activeAttemptCountBeforeFinish = Object.keys(status.activeAttempts || {}).length;
+const finishedAttempt = finishActiveAttempt();
+if (!finishedAttempt && (hookInput.attemptId || activeAttemptCountBeforeFinish > 0)) {
+  process.stdout.write('{}');
+  process.exit(0);
+}
+endHumanGateIfResumed();
 if (steps.length === 0 || pipeline.autoChain === false) {
   process.stdout.write('{}');
   process.exit(0);
@@ -242,38 +420,57 @@ if (status.awaitingHumanGate || status.state === 'awaiting_approval') {
   process.exit(0);
 }
 
+function nearestPrecedingStepIndex(agent, fromIndex, fallback) {
+  for (let index = fromIndex - 1; index >= 0; index -= 1) {
+    if (getStepAgents(steps[index]).includes(agent)) return index;
+  }
+  const match = steps.findIndex((step) => getStepAgents(step).includes(agent));
+  return match >= 0 ? match : fallback;
+}
+function scheduleRetry(agent, retryAfterFix, predecessor, explicitStepIndex = null) {
+  const currentIndex = typeof status.pipelineIndex === 'number' ? status.pipelineIndex : 0;
+  const stepIndex = Number.isInteger(explicitStepIndex) ? explicitStepIndex : nearestPrecedingStepIndex(agent, currentIndex, currentIndex);
+  const predecessorAttemptId = predecessor?.attemptId || status.lastCompletedAttempt?.attemptId || null;
+  appendMetric({ type: 'retry_scheduled', at: now, attemptId: predecessorAttemptId, nextAgent: agent, retryAfterFix: retryAfterFix || null, source: 'hook', attributionConfidence: predecessor ? predecessor.confidence : 'unknown' });
+  activateAttempts(steps[stepIndex] || { agent }, stepIndex);
+  return stepIndex;
+}
+
 if (status.state === 'changes_requested' && REVIEW_AGENTS.has(status.currentAgent)) {
   const reviewer = status.currentAgent;
+  const retryAfterFixStepIndex = typeof status.pipelineIndex === 'number' ? status.pipelineIndex : 0;
+  const developerIndex = scheduleRetry('feature-developer', reviewer, finishedAttempt);
   writeStatus({
+    pipelineIndex: developerIndex,
     currentAgent: 'feature-developer',
     state: 'in_progress',
     phase: 'executing',
     retryAfterFix: reviewer,
+    retryAfterFixStepIndex,
   });
-  out(
-    handoffForAgent('feature-developer') +
-      ` After fixes, re-run ${reviewer}.`,
-  );
+  out(handoffForAgent('feature-developer') + ` After fixes, re-run ${reviewer}.`);
   process.exit(0);
 }
 
 if (status.state === 'validation_failed' && status.currentAgent === 'build-verifier') {
+  const retryAfterFixStepIndex = typeof status.pipelineIndex === 'number' ? status.pipelineIndex : 0;
+  const developerIndex = scheduleRetry('feature-developer', 'build-verifier', finishedAttempt);
   writeStatus({
+    pipelineIndex: developerIndex,
     currentAgent: 'feature-developer',
     state: 'in_progress',
     phase: 'executing',
     retryAfterFix: 'build-verifier',
+    retryAfterFixStepIndex,
   });
-  out(
-    handoffForAgent('feature-developer') +
-      ` Read validation-report.md. After fixes, re-run build-verifier.`,
-  );
+  out(handoffForAgent('feature-developer') + ' Read validation-report.md. After fixes, re-run build-verifier.');
   process.exit(0);
 }
 
 if (status.state === 'completed' && status.retryAfterFix) {
   const retry = status.retryAfterFix;
-  writeStatus({ currentAgent: retry, state: 'in_progress', retryAfterFix: null });
+  const retryIndex = scheduleRetry(retry, null, finishedAttempt, status.retryAfterFixStepIndex);
+  writeStatus({ pipelineIndex: retryIndex, currentAgent: retry, state: 'in_progress', retryAfterFix: null, retryAfterFixStepIndex: null });
   out(handoffForAgent(retry));
   process.exit(0);
 }
@@ -286,7 +483,7 @@ if (!currentStep) {
   process.exit(0);
 }
 
-const completedAgent = status.currentAgent || getStepAgents(currentStep)[0];
+const completedAgent = finishedAttempt?.entry?.agent || status.currentAgent || getStepAgents(currentStep)[0];
 const stepAgents = getStepAgents(currentStep);
 
 if (currentStep.parallel && stepAgents.length > 1) {
@@ -304,6 +501,7 @@ if (currentStep.parallel && stepAgents.length > 1) {
 }
 
 if (hasGateAfterStep(currentStep, pipeline.humanGates)) {
+  beginHumanGate();
   writeStatus({
     awaitingHumanGate: true,
     state: 'awaiting_approval',
@@ -315,6 +513,7 @@ if (hasGateAfterStep(currentStep, pipeline.humanGates)) {
 
 const next = findNextExecutableStep(steps, idx + 1, taskDir);
 if (!next) {
+  completeTaskMetrics();
   writeStatus({
     pipelineIndex: steps.length,
     phase: 'done',
@@ -329,6 +528,7 @@ if (!next) {
 const { step: nextStep, index: nextIdx } = next;
 const nextAgents = getStepAgents(nextStep);
 
+activateAttempts(nextStep, nextIdx);
 writeStatus({
   pipelineIndex: nextIdx,
   currentAgent: nextAgents[0],

package/presets/cursor/mcp-ts/rules/README.md

@@ -50,3 +50,9 @@
 ## Catalog
 
 See Claude `rules/README.md` mapping table for the full Cursor→Claude stem list.
+
+## Metrics policy mapping
+
+| Shared core | Runtime integration | Loading |
+|-------------|---------------------|---------|
+| `agent-team/agent-task-metrics.md` | `agent-team-orchestrator` + `hooks/chain-team-phases.sh` | requestable/on-demand; never session-start |

package/presets/cursor/mcp-ts/rules/agent-team-orchestrator.mdc

@@ -61,6 +61,10 @@ flowchart TD
 
 **Source of truth for order:** `pipeline.json` → `steps[]`. Never hardcode analyst → dev → review → QA when `pipeline.json` exists.
 
+## Metrics lifecycle
+
+Use the local `metrics.json` ledger described by **agent-task-metrics**: initialize attempts before invocation, let hooks record host-clock ends, and never guess a parallel completion from `currentAgent`.
+
 ## status.json (pipeline mode)
 
 ```json

package/presets/cursor/mcp-ts/rules/preset-layering.mdc

@@ -24,7 +24,7 @@ alwaysApply: false
 ## Куда класть новое правило
 
 1. Общие принципы для всех стеков → **core** + адаптеры с `<!-- shared-core: … -->`.
-2. Только один из installable стеков (`next` / `ios-swift` / `go` / `java`) → **stack-specific** (не в `_shared`).
+2. Только один из installable стеков (`next` / `ios-swift` / `go` / `java` / `mcp-ts` / `php-hexagonal` / `php-laravel`) → **stack-specific** (не в `_shared`).
 3. Только Cursor или только Claude packaging → platform artifact / frontmatter, не дублировать семантику.
 
 ## SoT

package/presets/cursor/mcp-ts/rules/preset-no-cross-stack-leakage.mdc

@@ -17,7 +17,7 @@ alwaysApply: false
 
 - `next` must not require iOS-only agents/tooling (`xcuitest-*`, `xcodebuild` as required handoff, Keychain-only rules).
 - `ios-swift` must not ship Playwright handoffs or Next lint recipes as required commands.
-- `go` / `java` / `mcp-ts` must not ship Playwright, XCUITest, Next lint recipes, or `xcodebuild`/`SwiftLint` as required handoffs.
+- `go` / `java` / `php-hexagonal` / `php-laravel` / `mcp-ts` must not ship Playwright, XCUITest, Next lint recipes, or `xcodebuild`/`SwiftLint` as required handoffs.
 - `mcp-ts` must not ship Go tool commands (`go test`, `go vet`, `golangci-lint`) or `integration-test-*` agents as required delivery gates.
 - Shared core must not embed stack paths (`app/src/**`, `Features/**`, `playwright`, `xcodebuild`).
 
@@ -36,16 +36,16 @@ Required instead: `xcuitest-test-*` stems; build-verifier mentions `xcodebuild`
 - `xcuitest-test-` as handoff stems
 - Requiring `xcodebuild` / SwiftLint as the default post-change gate for Next app work
 
-## Forbidden in go / java hooks/agents (FAIL)
+## Forbidden in go / java / php-hexagonal / php-laravel hooks/agents (FAIL)
 
-Shared backend-stack bans (both `go` and `java`):
+Shared backend-stack bans (`go`, `java`, `php-hexagonal`, and `php-laravel`):
 
 - `playwright-test-`, `playwright-e2e`, `user-playwright`, `app/__tests__/e2e`
 - Positive yarn recipes `lint:js` / `lint:css`
 - `xcuitest-test-`, `xcodebuild`, `SwiftLint` as required handoffs
 - Agent file `accessibility-reviewer` (no UI surface)
 
-Required instead: `integration-test-*`; build-verifier / `post-change-test` plus stack tooling — `go-tooling` (`go test`, `go vet`) or `java-tooling` (`mvn test` / `./gradlew test`).
+Required instead: `integration-test-*`; build-verifier / `post-change-test` plus stack tooling — `go-tooling` (`go test`, `go vet`), `java-tooling` (`mvn test` / `./gradlew test`), or `php-tooling` (`php artisan test` / `composer test` / `vendor/bin/phpunit`).
 
 ## Forbidden in mcp-ts hooks/agents (FAIL)
 
@@ -66,4 +66,4 @@ Required instead: package-manager–discovered typecheck/test (`mcp-ts-tooling`,
 
 ## Chain fork
 
-`hooks/chain-team-phases.sh` must differ **byte-wise** pairwise among `next`, `ios-swift`, `go`, `java`, and `mcp-ts` (per platform).
+`hooks/chain-team-phases.sh` must differ **byte-wise** pairwise among `next`, `ios-swift`, `go`, `java`, `mcp-ts`, `php-hexagonal`, and `php-laravel` (per platform).

package/presets/cursor/mcp-ts/rules/preset-pr-checklist.mdc

@@ -17,7 +17,7 @@ alwaysApply: false
 
 - [ ] **SoT:** правки в `packages/…` (не только root `.cursor/`)
 - [ ] **Core:** если менялся `_shared/core/**` — обновлены все `<!-- shared-core: … -->` consumers (или documented intentional fork)
-- [ ] **Twin:** Cursor change → Claude twin **same PR** (**FAIL** if missing on next, ios-swift, go, and java — см. `preset-twin-sync`)
+- [ ] **Twin:** Cursor change → Claude twin **same PR** (**FAIL** if missing on next, ios-swift, go, java, mcp-ts, php-hexagonal, and php-laravel — см. `preset-twin-sync`)
 - [ ] **Mapping:** `claude/<stack>/rules/README.md` mapping table актуален
 - [ ] **Token budget:** alwaysApply / session-start ≤ 3; meta rules not always-on
 - [ ] **Leakage:** нет чужих stack agent stems / handoff strings (`preset-no-cross-stack-leakage`)

package/presets/cursor/mcp-ts/rules/preset-twin-sync.mdc

@@ -22,6 +22,8 @@ Cursor `.mdc` — **SoT per stack**. Claude topic `.md` — derived twin.
 | `go` | `presets/cursor/go/rules/*.mdc` | `presets/claude/go/rules/<topic>/` | Keep in `claude/go/rules/README.md` |
 | `java` | `presets/cursor/java/rules/*.mdc` | `presets/claude/java/rules/<topic>/` | Keep in `claude/java/rules/README.md` |
 | `mcp-ts` | `presets/cursor/mcp-ts/rules/*.mdc` | `presets/claude/mcp-ts/rules/<topic>/` | Keep in `claude/mcp-ts/rules/README.md` |
+| `php-hexagonal` | `presets/cursor/php-hexagonal/rules/*.mdc` | `presets/claude/php-hexagonal/rules/<topic>/` | Keep in `claude/php-hexagonal/rules/README.md` |
+| `php-laravel` | `presets/cursor/php-laravel/rules/*.mdc` | `presets/claude/php-laravel/rules/<topic>/` | Keep in `claude/php-laravel/rules/README.md` |
 
 ## Same-PR checklist
 
@@ -42,5 +44,7 @@ Cursor `.mdc` — **SoT per stack**. Claude topic `.md` — derived twin.
 - **go:** missing Claude twin for a changed Cursor rule → **FAIL** (same as next / ios-swift; mapping table required).
 - **java:** missing Claude twin for a changed Cursor rule → **FAIL** (same as next / ios-swift / go; mapping table required).
 - **mcp-ts:** missing Claude twin for a changed Cursor rule → **FAIL** (same as next / ios-swift / go / java; mapping table required).
+- **php-hexagonal:** missing Claude twin for a changed Cursor rule → **FAIL** (same as next / ios-swift / go / java / mcp-ts; mapping table required).
+- **php-laravel:** missing Claude twin for a changed Cursor rule → **FAIL** (same as next / ios-swift / go / java / mcp-ts / php-hexagonal; mapping table required).
 
 Dogfood: sync packages → root `.cursor/` after Cursor SoT changes (not the reverse). Use `packages/ai-rules/scripts/sync-dogfood-cursor.sh`.

package/presets/cursor/mcp-ts/rules/technical-retro.mdc

@@ -11,8 +11,6 @@ alwaysApply: false
 
 **`commands/technical-retro.md`** → `/technical-retro`
 
-Используй rule только если command недоступен. Не дублируй содержимое command в ответе — следуй command-файлу и skill `technical-retro`.
-
-## Stack notes
+When a task has `metrics.json`, use the local aggregation script and state the cohort, sample size, incomplete artifacts, attribution confidence, active attempt duration, and human-gate wait separately. Do not score malformed artifacts or gate wait as agent work.
 
-- **Phase 1:** skill `technical-retro` is not shipped — follow `commands/technical-retro.md` only; do not fail if the skill is absent (Phase 2 may add the skill).
+Используй rule только если command недоступен. Не дублируй содержимое command в ответе — следуй command-файлу и skill `technical-retro`.

package/presets/cursor/mcp-ts/team/README.md

@@ -15,3 +15,11 @@ Phase 1 agents: see `agents/README.md`.
 `task-router`, `task-analyst`, `solution-architect`, `feature-developer`, `build-verifier`, `security-reviewer`.
 
 Do **not** name Phase 2 agents (`contract-test-*`, `debugger`, Playwright stems, etc.) in fixture JSON — even as skips. Defer those until the agents ship.
+
+## Local metrics ledger
+
+`metrics.json` is an append-only schema-v1 event ledger for one task run. It contains only allowlisted IDs, task dimensions, timestamps, outcomes, and attribution confidence—never prompts, secrets, file paths, or contents. The router writes `task_started` / `attempt_started`; the hook records host-clock completion and human-gate edges under a per-task lock with temp-and-rename.
+
+`status.json.activeAttempts` is a transient timing bridge keyed by `attemptId`; `lastCompletedAttempt` is diagnostic. For parallel stops, the hook must use a stable payload identity or the sole active attempt. Otherwise an explicit `.metrics-receipts.json` receipt is fallback data marked `source: agent`, `attributionConfidence: fallback`; it must never guess from `currentAgent`.
+
+Aggregate with `node packages/ai-rules/scripts/aggregate-agent-task-metrics.mjs --team-root .cursor/team`. It reports role/agent count, completed count, total/average duration, distinct completed run IDs, separate human-gate wait, and incomplete artifacts.

package/presets/cursor/next/agents/build-verifier.md

@@ -36,14 +36,14 @@ When validating **preset packaging** changes (paths under `packages/ai-rules/pre
 2. **Leakage (next):** hooks/agents must not require `xcuitest-test-*` handoffs or `xcodebuild` as the default Next post-change gate. See `preset-no-cross-stack-leakage.mdc`.
 3. **Mapping / README:** `claude/next/rules/README.md` must include a Cursor→Claude mapping table; stack `rules/README.md` should document core→stack mapping when `_shared` consumers exist.
 4. **shared-core consumers:** if `_shared/core/**` changed, every file with matching `<!-- shared-core: … -->` in this PR must be updated (or intentional fork documented in validation-report).
-5. **Twin presence:** Cursor rule change without Claude twin same PR → **FAIL** (next, ios-swift, go, and java). Domain twin body ≥15 lines; thin aliases (`agent-team-intake`, `technical-retro`) may be shorter.
+5. **Twin presence:** Cursor rule change without Claude twin same PR → **FAIL** (next, ios-swift, go, java, mcp-ts, php-hexagonal, and php-laravel). Domain twin body ≥15 lines; thin aliases (`agent-team-intake`, `technical-retro`) may be shorter.
 6. **Session-start body budget (soft→document, FAIL if grossly over):** sum body lines of the **3** intended always-on / session-start rules ≤ **140** (stretch ≤120); do **not** include `**/README.md`. Record the sum in validation-report.
 7. **Embed drift (hard in `check:preset-structure`):** run `packages/ai-rules/scripts/check-shared-core-drift.sh` with `AI_RULES_DRIFT_FAIL=1` (bundled by the structure orchestrator). Lineage stems are excluded from body equality.
 8. **Dogfood (monorepo soft):** if root `.cursor/` is in the PR, prefer sync via `packages/ai-rules/scripts/sync-dogfood-cursor.sh`; mass deletion of tracked dogfood without migration doc → note as risk / FAIL for maintainers.
 
-9. **Root AGENTS template:** each installable preset (`cursor|claude` × `next|ios-swift|go|java`) must ship `REPO_AGENTS.md` when validating preset packaging → **FAIL** if missing.
+9. **Root AGENTS template:** each installable preset (`cursor|claude` × `next|ios-swift|go|java|mcp-ts|php-hexagonal`) must ship `REPO_AGENTS.md` when validating preset packaging → **FAIL** if missing.
 10. **Hooks cookbook:** default `hooks.json` must **not** reference `hooks/examples/` → **FAIL** if it does.
-11. **No react-performance on ios/go/java:** skill directory / required handoff must be absent under ios-swift, go, and java → **FAIL** (leakage). Prefer `check:preset-leakage`.
+11. **No react-performance on ios/go/java:** skill directory / required handoff must be absent under ios-swift, go, java, mcp-ts, php-hexagonal, and php-laravel → **FAIL** (leakage). Prefer `check:preset-leakage`.
 12. **Rule eval (WARN):** `scripts/check-rule-eval.mjs` / `yarn check:rule-eval` should exist for maintainers; smoke optional. Hard fail only when the opt-in eval job runs — not part of default `check:preset-structure`.
 
 ### Soft notes

package/presets/cursor/next/agents/task-router.md

@@ -107,3 +107,7 @@ Write `.cursor/team/tasks/<slug>/pipeline.json` and initial `status.json` via th
 5. Invoke `steps[0].agent` now (unless `retro` → `/technical-retro`).
 
 Do not invoke implementation agents yourself.
+
+## Metrics initialization
+
+Alongside `pipeline.json` and `status.json`, create `metrics.json` with `schemaVersion: 1`, immutable task dimensions, `task_started`, and a generated `runId`. Before the parent invokes each agent, append `attempt_started` and set `status.activeAttempts[attemptId]` with agent, step index, attempt number, and host-clock `startedAt`. For parallel work create one entry per agent; do not use `currentAgent` to identify their completion.

package/presets/cursor/next/commands/task-continue.md

@@ -22,22 +22,19 @@ description: Continue an agent-team task after a human gate, pause, or review ch
 ## Алгоритм
 
 1. Запиши `.cursor/team/active-task.json` → `{ "slug": "<slug>" }`.
-2. Сбрось gate: `awaitingHumanGate: false`.
-3. Определи **следующий шаг**:
-   - После approval analyst/architect: `pipelineIndex + 1` → следующий agent в `steps`.
-   - После `changes_requested`: снова **feature-developer** (тот же index или найди developer в steps).
-4. Обнови `status.json`:
-   ```json
-   {
-     "pipelineIndex": <n>,
-     "currentAgent": "<steps[n].agent>",
-     "phase": "executing",
-     "state": "in_progress",
-     "awaitingHumanGate": false
-   }
-   ```
-5. Вызови subagent для `currentAgent` с контекстом slug и артефактов.
-6. Hook `chain-team-phases.sh` продолжит цепочку по `pipeline.json`, если `autoChain: true`.
+2. **Human gate resume** (`awaitingHumanGate` / `awaiting_approval`):
+   1. **Do not** manually increment `pipelineIndex` or invent `currentAgent` first.
+   2. Close the gate + activate the next attempt via the **installed** hook (single authority for ledger + status):
+
+```bash
+printf '%s\n' '{"status":"completed","action":"end_human_gate","activateNext":true}' | bash .cursor/hooks/chain-team-phases.sh
+```
+
+   3. Re-read `status.json` (and the hook `followup_message`).
+   4. Invoke the subagent named in `status.currentAgent` / followup — do **not** advance the pipeline a second time.
+3. **Review `changes_requested`** (not a human gate): set `currentAgent` to `feature-developer` (same index / find developer in steps), `state: in_progress`, then invoke developer. Do **not** call `end_human_gate` unless `activeHumanGateEventId` is set.
+4. **Other resume**: restore `pipelineIndex` / `currentAgent` from status and invoke that agent.
+5. After the invoked agent completes, `chain-team-phases.sh` on `subagentStop` continues the chain when `autoChain: true`.
 
 ## Артефакты для handoff
 
@@ -47,3 +44,7 @@ description: Continue an agent-team task after a human gate, pause, or review ch
 | build-verifier | git diff, decomposition.md |
 | code-reviewer | brief.md, validation-report.md, git diff |
 | qa-tester | brief.md, decomposition.md, scope from pipeline step |
+
+## Metrics
+
+On human-gate resume, the hook action above appends `human_gate_ended` under the per-task lock **before** any new `attempt_started`. Agents must not calculate durations.

package/presets/cursor/next/commands/task.md

@@ -48,3 +48,7 @@ description: Route a natural-language task through the agent-team pipeline: task
 ## Legacy
 
 `/feature-start` и `/feature-continue` остаются совместимыми; для новых задач предпочитай `/task`.
+
+## Metrics
+
+Initialize `metrics.json` before the first invocation with frozen task dimensions and `task_started`; add one `activeAttempts[attemptId]` entry plus `attempt_started` per scheduled agent. On `/task-continue`, append `human_gate_ended` (referencing the stored gate event) before activating the next attempt. Do not calculate durations in agents.

package/presets/cursor/next/commands/technical-retro.md

@@ -79,3 +79,7 @@ description: Facilitate a technical retrospective for a period, incident, releas
 - Не приписывать цитаты и факты без входа.
 - Не выдавать HR‑рекомендации.
 - Если просят только шаблон — **шаблон повестки** без выдуманного контента.
+
+### Metrics evidence
+
+When `metrics.json` exists, run the local aggregation script and report the cohort, sample size, incomplete artifacts, attribution confidence, active attempt duration, and human-gate wait separately. Do not treat gate wait or malformed ledgers as agent duration.