Antigravity × Feature Flags & Progressive Delivery — AI エージェントでリリースリスクをゼロに近づける実践戦略

// feature-flags.ts — 型安全な Feature Flag システムの基盤設計
// Antigravity エージェントに「型安全な Feature Flag マネージャーを作って」と指示すると
// このような構造を自動生成できます
 
type FlagType = 'release' | 'experiment' | 'ops' | 'permission';
 
interface FeatureFlag<T = boolean> {
  key: string;
  type: FlagType;
  defaultValue: T;
  description: string;
  owner: string;        // 責任者（フラグの寿命管理のため）
  createdAt: string;
  expiresAt?: string;   // リリースフラグは必ず有効期限を設定
}
 
interface FlagEvaluationContext {
  userId: string;
  userAttributes: Record<string, string | number | boolean>;
  environment: 'production' | 'staging' | 'development';
  percentage?: number;  // 段階ロールアウト用（0-100）
}
 
// フラグ定義の一元管理
const FLAGS = {
  newCheckoutFlow: {
    key: 'new-checkout-flow',
    type: 'release' as FlagType,
    defaultValue: false,
    description: '新しい決済フローUI',
    owner: 'payment-team',
    createdAt: '2026-03-30',
    expiresAt: '2026-04-30', // 1ヶ月後に必ず評価
  },
  pricingExperiment: {
    key: 'pricing-experiment',
    type: 'experiment' as FlagType,
    defaultValue: 'control', // 'control' | 'variant-a' | 'variant-b'
    description: '料金ページのA/Bテスト',
    owner: 'growth-team',
    createdAt: '2026-03-30',
  },
  emergencyReadOnly: {
    key: 'emergency-read-only',
    type: 'ops' as FlagType,
    defaultValue: false,
    description: '緊急時の読み取り専用モード',
    owner: 'sre-team',
    createdAt: '2026-03-30',
  },
} as const;
 
// 出力例:
// FLAGS.newCheckoutFlow.key → 'new-checkout-flow'
// FLAGS.pricingExperiment.type → 'experiment'

<!-- .antigravity/rules/feature-flags.md -->
# Feature Flag ルール
 
## 命名規則
- ケバブケースを使用: `new-checkout-flow`
- プレフィックスでタイプを示す: `exp-`（実験）, `ops-`（運用）, `perm-`（権限）
- リリースフラグはプレフィックスなし
 
## 必須フィールド
- すべてのフラグに `owner` と `createdAt` を設定
- リリースフラグには `expiresAt` を必ず設定（最長30日）
- 実験フラグには `variants` と `metrics` を定義
 
## フラグの除去
- 有効期限を過ぎたフラグは、次のスプリントで必ず除去する
- フラグ除去時は関連するテストコードも同時に除去する

// hooks/useFeatureFlag.ts — Antigravity が生成するカスタムフック
// エージェントへの指示: 「Cloudflare KV をバックエンドに使う Feature Flag フックを作って」
 
import { useEffect, useState } from 'react';
 
interface FlagConfig {
  key: string;
  defaultValue: boolean;
  userId?: string;
}
 
export function useFeatureFlag({ key, defaultValue, userId }: FlagConfig): {
  enabled: boolean;
  loading: boolean;
} {
  const [enabled, setEnabled] = useState(defaultValue);
  const [loading, setLoading] = useState(true);
 
  useEffect(() => {
    const controller = new AbortController();
 
    async function fetchFlag() {
      try {
        const params = new URLSearchParams({ key });
        if (userId) params.append('userId', userId);
 
        const res = await fetch(`/api/flags?${params}`, {
          signal: controller.signal,
        });
 
        if (res.ok) {
          const data = await res.json();
          setEnabled(data.enabled);
        }
      } catch (err) {
        if (err instanceof DOMException && err.name === 'AbortError') return;
        console.warn(`Flag evaluation failed for ${key}, using default`);
      } finally {
        setLoading(false);
      }
    }
 
    fetchFlag();
    return () => controller.abort();
  }, [key, userId]);
 
  return { enabled, loading };
}
 
// コンポーネントでの使用例:
// const { enabled: showNewUI, loading } = useFeatureFlag({
//   key: 'new-checkout-flow',
//   defaultValue: false,
//   userId: session.userId,
// });
// if (loading) return <Skeleton />;
// return showNewUI ? <NewCheckout /> : <LegacyCheckout />;

// api/flags/route.ts — エッジで動作するフラグ評価 API
// Antigravity にこのファイルの雛形を生成させ、ビジネスロジックを追加していく
 
import { NextRequest, NextResponse } from 'next/server';
import { getCloudflareContext } from '@opennextjs/cloudflare';
 
interface FlagRule {
  enabled: boolean;
  percentage?: number;     // 段階ロールアウト: 0-100
  allowList?: string[];    // 特定ユーザーのホワイトリスト
  startDate?: string;      // スケジュールリリース開始
  endDate?: string;        // スケジュールリリース終了
}
 
function hashUserId(userId: string, flagKey: string): number {
  // 決定論的なハッシュ: 同じユーザーには常に同じ結果を返す
  let hash = 0;
  const input = `${userId}:${flagKey}`;
  for (let i = 0; i < input.length; i++) {
    const char = input.charCodeAt(i);
    hash = ((hash << 5) - hash) + char;
    hash = hash & hash; // 32bit整数に変換
  }
  return Math.abs(hash) % 100;
}
 
export async function GET(request: NextRequest) {
  const { searchParams } = new URL(request.url);
  const key = searchParams.get('key');
  const userId = searchParams.get('userId');
 
  if (!key) {
    return NextResponse.json({ error: 'key is required' }, { status: 400 });
  }
 
  try {
    const { env } = await getCloudflareContext();
    const raw = await env.FLAGS_KV.get(`flag:${key}`);
 
    if (!raw) {
      return NextResponse.json({ enabled: false, source: 'default' });
    }
 
    const rule: FlagRule = JSON.parse(raw);
 
    // ホワイトリストチェック
    if (userId && rule.allowList?.includes(userId)) {
      return NextResponse.json({ enabled: true, source: 'allowList' });
    }
 
    // スケジュールチェック
    const now = new Date();
    if (rule.startDate && now < new Date(rule.startDate)) {
      return NextResponse.json({ enabled: false, source: 'scheduled' });
    }
    if (rule.endDate && now > new Date(rule.endDate)) {
      return NextResponse.json({ enabled: false, source: 'expired' });
    }
 
    // 段階ロールアウト
    if (rule.percentage !== undefined && userId) {
      const bucket = hashUserId(userId, key);
      const enabled = bucket < rule.percentage;
      return NextResponse.json({ enabled, source: 'percentage', bucket });
    }
 
    return NextResponse.json({ enabled: rule.enabled, source: 'rule' });
  } catch (err) {
    console.error('Flag evaluation error:', err);
    return NextResponse.json({ enabled: false, source: 'error' });
  }
}
 
// KV に格納するフラグデータの例:
// key: "flag:new-checkout-flow"
// value: {"enabled":true,"percentage":10,"allowList":["user-beta-1"]}
// → 全体の10%のユーザー + ベータテスターに新UIを表示

// scripts/bucket-independence.mjs — 手元の Node.js でそのまま動きます
import crypto from 'crypto';
 
const N = 100_000;
const users = Array.from({ length: N }, () => crypto.randomUUID());
const keys = ['new-checkout-flow', 'exp-onboarding-copy', 'ops-image-pipeline',
              'perm-beta-widgets', 'release-dark-mode'];
 
// 記事前半で使っていた 31 進ハッシュ
const naive = (u, k) => {
  let h = 0; const s = `${u}:${k}`;
  for (let i = 0; i < s.length; i++) { h = ((h << 5) - h) + s.charCodeAt(i); h = h & h; }
  return Math.abs(h) % 100;
};
 
const cohorts = keys.map(k => new Set(users.filter(u => naive(u, k) < 10)));
for (let i = 0; i < keys.length; i++) {
  for (let j = i + 1; j < keys.length; j++) {
    let overlap = 0;
    for (const u of cohorts[i]) if (cohorts[j].has(u)) overlap++;
    console.log(keys[i], 'x', keys[j], (overlap / N * 100).toFixed(2) + '%');
  }
}

// api/flags/lib/bucket.ts — フラグ間で独立なバケット割り当て
function fnv1a(input: string): number {
  let hash = 0x811c9dc5;
  for (let i = 0; i < input.length; i++) {
    hash ^= input.charCodeAt(i);
    hash = Math.imul(hash, 0x01000193) >>> 0;
  }
  return hash >>> 0;
}
 
// murmur3 の finalizer。下位ビットに上位ビットの情報を混ぜ込みます
function avalanche(hash: number): number {
  hash ^= hash >>> 16;
  hash = Math.imul(hash, 0x85ebca6b) >>> 0;
  hash ^= hash >>> 13;
  hash = Math.imul(hash, 0xc2b2ae35) >>> 0;
  hash ^= hash >>> 16;
  return hash >>> 0;
}
 
export function bucketFor(userId: string, flagKey: string): number {
  // フラグキーを先頭に置き、最後に撹拌してから 100 で割る
  return avalanche(fnv1a(`${flagKey}:${userId}`)) % 100;
}

// scripts/canary-rollout.ts — Antigravity エージェントが管理するロールアウトスクリプト
// 「カナリアリリースの自動ロールアウトスクリプトを作って」と指示
 
interface RolloutStage {
  percentage: number;
  duration: string;      // この段階を維持する時間
  successCriteria: {
    maxErrorRate: number;  // 許容エラー率（%）
    maxLatencyP99: number; // 許容P99レイテンシ（ms）
    minSuccessRate: number; // 最低成功率（%）
  };
}
 
const ROLLOUT_PLAN: RolloutStage[] = [
  {
    percentage: 1,
    duration: '30m',
    successCriteria: { maxErrorRate: 0.1, maxLatencyP99: 500, minSuccessRate: 99.9 },
  },
  {
    percentage: 5,
    duration: '1h',
    successCriteria: { maxErrorRate: 0.5, maxLatencyP99: 800, minSuccessRate: 99.5 },
  },
  {
    percentage: 25,
    duration: '2h',
    successCriteria: { maxErrorRate: 1.0, maxLatencyP99: 1000, minSuccessRate: 99.0 },
  },
  {
    percentage: 50,
    duration: '4h',
    successCriteria: { maxErrorRate: 1.0, maxLatencyP99: 1000, minSuccessRate: 99.0 },
  },
  {
    percentage: 100,
    duration: 'permanent',
    successCriteria: { maxErrorRate: 1.0, maxLatencyP99: 1200, minSuccessRate: 98.5 },
  },
];
 
async function evaluateMetrics(flagKey: string): Promise<{
  errorRate: number;
  latencyP99: number;
  successRate: number;
}> {
  // 実際にはモニタリングツール（Grafana, Datadog等）のAPIから取得
  // Antigravity エージェントが使用中のモニタリングスタックに合わせて実装を生成
  const response = await fetch(`https://monitoring.example.com/api/metrics`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      query: `feature_flag{key="${flagKey}"}`,
      range: '15m',
    }),
  });
  return response.json();
}
 
async function updateFlagPercentage(flagKey: string, percentage: number): Promise<void> {
  // Cloudflare KV のフラグ値を更新
  await fetch(`https://api.cloudflare.com/client/v4/accounts/{account_id}/storage/kv/namespaces/{namespace_id}/values/flag:${flagKey}`, {
    method: 'PUT',
    headers: {
      'Authorization': `Bearer YOUR_API_KEY`,
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({ enabled: true, percentage }),
  });
}
 
async function rollback(flagKey: string, reason: string): Promise<void> {
  console.error(`🚨 ROLLBACK: ${flagKey} — ${reason}`);
  await updateFlagPercentage(flagKey, 0);
  // Slack / Discord 通知
  // Antigravity エージェントに「Slack通知機能を追加して」と依頼すると自動実装
}
 
async function executeRollout(flagKey: string): Promise<void> {
  for (const stage of ROLLOUT_PLAN) {
    console.log(`📊 Stage: ${stage.percentage}% rollout`);
    await updateFlagPercentage(flagKey, stage.percentage);
 
    // 指定時間待機してメトリクスを収集
    const waitMs = parseDuration(stage.duration);
    if (waitMs === Infinity) break; // permanent = 最終段階
 
    await new Promise(resolve => setTimeout(resolve, waitMs));
 
    // メトリクス評価
    const metrics = await evaluateMetrics(flagKey);
 
    if (metrics.errorRate > stage.successCriteria.maxErrorRate) {
      await rollback(flagKey, `Error rate ${metrics.errorRate}% exceeds threshold ${stage.successCriteria.maxErrorRate}%`);
      return;
    }
    if (metrics.latencyP99 > stage.successCriteria.maxLatencyP99) {
      await rollback(flagKey, `P99 latency ${metrics.latencyP99}ms exceeds threshold ${stage.successCriteria.maxLatencyP99}ms`);
      return;
    }
    if (metrics.successRate < stage.successCriteria.minSuccessRate) {
      await rollback(flagKey, `Success rate ${metrics.successRate}% below threshold ${stage.successCriteria.minSuccessRate}%`);
      return;
    }
 
    console.log(`✅ Stage ${stage.percentage}% passed — metrics OK`);
  }
 
  console.log('🎉 Rollout complete — 100% traffic');
}
 
function parseDuration(d: string): number {
  if (d === 'permanent') return Infinity;
  const match = d.match(/^(\d+)(m|h)$/);
  if (!match) throw new Error(`Invalid duration: ${d}`);
  const [, num, unit] = match;
  return parseInt(num) * (unit === 'h' ? 3600000 : 60000);
}
 
// 実行例:
// executeRollout('new-checkout-flow');
// → 1% → 5% → 25% → 50% → 100% と段階的にロールアウト
// → 各段階でメトリクスを自動チェック、異常があれば即座にロールバック

// lib/ab-testing.ts — A/Bテスト管理モジュール
// Antigravity に「統計的検定付きのA/Bテストライブラリを実装して」と指示
 
interface Experiment {
  key: string;
  variants: string[];     // ['control', 'variant-a', 'variant-b']
  trafficAllocation: number; // 実験に参加するトラフィックの割合（0-100）
  metrics: string[];      // 追跡するメトリクス名
}
 
interface ExperimentResult {
  variant: string;
  sampleSize: number;
  conversions: number;
  conversionRate: number;
}
 
// Z検定による統計的有意性の判定
function calculateZScore(
  control: ExperimentResult,
  treatment: ExperimentResult
): { zScore: number; pValue: number; significant: boolean } {
  const p1 = control.conversionRate;
  const p2 = treatment.conversionRate;
  const n1 = control.sampleSize;
  const n2 = treatment.sampleSize;
 
  // プールされた比率
  const pooled = (control.conversions + treatment.conversions) / (n1 + n2);
  const se = Math.sqrt(pooled * (1 - pooled) * (1 / n1 + 1 / n2));
 
  if (se === 0) return { zScore: 0, pValue: 1, significant: false };
 
  const zScore = (p2 - p1) / se;
 
  // 両側検定の p値（近似計算）
  const pValue = 2 * (1 - normalCDF(Math.abs(zScore)));
 
  return {
    zScore,
    pValue,
    significant: pValue < 0.05, // 95% 信頼水準
  };
}
 
function normalCDF(x: number): number {
  // 標準正規分布の累積分布関数（Abramowitz & Stegun 近似）
  const t = 1 / (1 + 0.2316419 * Math.abs(x));
  const d = 0.3989422804014327;
  const p =
    d * Math.exp(-x * x / 2) *
    (t * (0.3193815 + t * (-0.3565638 + t * (1.781478 + t * (-1.821256 + t * 1.330274)))));
  return x > 0 ? 1 - p : p;
}
 
// 必要サンプルサイズの事前計算
function requiredSampleSize(
  baselineRate: number,        // 現在のコンバージョン率
  minimumDetectableEffect: number, // 検出したい最小効果量
  power: number = 0.8,         // 検出力（通常80%）
  alpha: number = 0.05         // 有意水準（通常5%）
): number {
  const zAlpha = 1.96;  // α=0.05 の z値
  const zBeta = 0.842;  // β=0.2（power=0.8）の z値
  const p1 = baselineRate;
  const p2 = baselineRate + minimumDetectableEffect;
  const pBar = (p1 + p2) / 2;
 
  const n = Math.ceil(
    (Math.pow(zAlpha + zBeta, 2) * (p1 * (1 - p1) + p2 * (1 - p2))) /
    Math.pow(p2 - p1, 2)
  );
 
  return n;
}
 
// 出力例:
// requiredSampleSize(0.03, 0.005)
// → 約14,752（各バリアントに必要なサンプル数）
// 現在のCVR 3% で、0.5%ポイントの改善を検出するには
// 各バリアント約15,000サンプルが必要

// scripts/release-risk-analysis.ts — AI駆動のリリースリスク分析
// Antigravity の Agent モードで実行し、コードベース全体を考慮した分析を行う
 
interface RiskFactor {
  category: 'code' | 'dependency' | 'config' | 'database' | 'infrastructure';
  severity: 'low' | 'medium' | 'high' | 'critical';
  description: string;
  mitigation: string;
}
 
interface ReleaseRiskReport {
  overallRisk: 'low' | 'medium' | 'high' | 'critical';
  factors: RiskFactor[];
  recommendedRolloutStrategy: string;
  flagsToCreate: string[];
  testsCoverage: {
    newCode: number;      // 新規コードのテストカバレッジ
    modifiedCode: number; // 変更コードのテストカバレッジ
  };
}
 
// Antigravity エージェントへの指示テンプレート（AGENTS.md に記載）
const RISK_ANALYSIS_PROMPT = `
## リリースリスク分析タスク
 
以下の観点でコード差分を分析し、リスクレポートを生成してください:
 
1. **コードリスク**
   - 変更の影響範囲（ファイル数、関数数）
   - 複雑度の変化（循環的複雑度）
   - エラーハンドリングの網羅性
   - 型安全性の確認
 
2. **依存関係リスク**
   - 新しい外部依存の追加
   - メジャーバージョンアップデート
   - セキュリティアドバイザリの有無
 
3. **設定変更リスク**
   - 環境変数の追加・変更
   - インフラ設定の変更
   - Feature Flags の追加
 
4. **データベースリスク**
   - マイグレーションの有無
   - 破壊的スキーマ変更の有無
   - データバックフィルの必要性
 
5. **推奨ロールアウト戦略**
   - リスクレベルに応じた段階ロールアウト計画
   - 作成すべき Feature Flags のリスト
   - ロールバック手順の提案
`;
 
// GitHub Actions でリスク分析を自動実行する設定例
// .github/workflows/release-risk.yml の内容を
// Antigravity エージェントに生成させる

// lib/auto-rollback.ts — メトリクス監視と自動ロールバック
// Antigravity に「Cloudflare Analytics APIを使った自動ロールバックを実装して」と依頼
 
interface MetricThreshold {
  metric: string;
  operator: 'gt' | 'lt' | 'gte' | 'lte';
  value: number;
  window: string;  // 評価ウィンドウ: '5m', '15m', '1h'
}
 
interface RollbackPolicy {
  flagKey: string;
  thresholds: MetricThreshold[];
  cooldownMinutes: number;  // ロールバック後の再有効化禁止期間
  notifyChannels: string[];
}
 
const ROLLBACK_POLICIES: RollbackPolicy[] = [
  {
    flagKey: 'new-checkout-flow',
    thresholds: [
      { metric: 'error_rate', operator: 'gt', value: 2.0, window: '5m' },
      { metric: 'p99_latency_ms', operator: 'gt', value: 2000, window: '5m' },
      { metric: 'checkout_success_rate', operator: 'lt', value: 95, window: '15m' },
    ],
    cooldownMinutes: 60,
    notifyChannels: ['slack:payments-alerts', 'pagerduty:checkout'],
  },
];
 
async function monitorAndRollback(policy: RollbackPolicy): Promise<void> {
  const checkInterval = 60_000; // 1分ごとにチェック
 
  while (true) {
    await new Promise(r => setTimeout(r, checkInterval));
 
    for (const threshold of policy.thresholds) {
      const currentValue = await getMetricValue(
        threshold.metric,
        threshold.window
      );
 
      const violated = evaluateThreshold(currentValue, threshold);
 
      if (violated) {
        console.error(
          `🚨 Threshold violated: ${threshold.metric} = ${currentValue} ` +
          `(${threshold.operator} ${threshold.value})`
        );
 
        // 即座にロールバック
        await executeRollback(policy.flagKey);
 
        // 通知送信
        for (const channel of policy.notifyChannels) {
          await sendNotification(channel, {
            type: 'rollback',
            flagKey: policy.flagKey,
            reason: `${threshold.metric} = ${currentValue}`,
            timestamp: new Date().toISOString(),
          });
        }
 
        // クールダウン
        console.log(`⏸️ Cooldown: ${policy.cooldownMinutes}m`);
        await new Promise(r =>
          setTimeout(r, policy.cooldownMinutes * 60_000)
        );
        break;
      }
    }
  }
}
 
function evaluateThreshold(
  value: number,
  threshold: MetricThreshold
): boolean {
  switch (threshold.operator) {
    case 'gt':  return value > threshold.value;
    case 'lt':  return value < threshold.value;
    case 'gte': return value >= threshold.value;
    case 'lte': return value <= threshold.value;
  }
}
 
async function getMetricValue(metric: string, window: string): Promise<number> {
  // Cloudflare Analytics API または外部モニタリングツールから取得
  // 実装はプロジェクトのインフラに合わせて Antigravity が自動生成
  return 0;
}
 
async function executeRollback(flagKey: string): Promise<void> {
  // KV のフラグを無効化
  console.log(`🔄 Rolling back flag: ${flagKey}`);
}
 
async function sendNotification(
  channel: string,
  payload: Record<string, string>
): Promise<void> {
  // Slack / PagerDuty / Discord への通知
  console.log(`📢 Notification sent to ${channel}`);
}
 
// 出力例（ロールバック発動時）:
// 🚨 Threshold violated: error_rate = 3.2 (gt 2.0)
// 🔄 Rolling back flag: new-checkout-flow
// 📢 Notification sent to slack:payments-alerts
// 📢 Notification sent to pagerduty:checkout
// ⏸️ Cooldown: 60m

# scripts/canary_power.py — python3 canary_power.py でそのまま動きます
import math
from math import comb
 
def binom_tail_ge(n, k, p):
    """n 件中 k 件以上が失敗する確率（厳密計算）"""
    if k <= 0:
        return 1.0
    if k > n:
        return 0.0
    return sum(comb(n, i) * p**i * (1 - p)**(n - i) for i in range(k, n + 1))
 
def min_k_exceeding(n, thr):
    """割合が thr を超えるために必要な最小の失敗件数"""
    return math.floor(thr * n) + 1
 
def fire_prob(n, thr, p):
    """真のエラー率が p のとき、1 ウィンドウで しきい値超え と判定される確率"""
    return binom_tail_ge(n, min_k_exceeding(n, thr), p)
 
TRAFFIC_PER_MIN = 200   # 全体のリクエスト数
P0   = 0.01             # 平常時のエラー率
THR  = 0.02             # ロールバックのしきい値
WIN  = 5                # 評価ウィンドウ（分）
EVAL = 60               # 1 時間の評価回数（1 分間隔）
 
for exposure in (0.01, 0.05, 0.25, 0.50, 1.00):
    n = int(TRAFFIC_PER_MIN * WIN * exposure)
    once  = fire_prob(n, THR, P0)          # 平常なのに発火する確率
    hour  = 1 - (1 - once) ** EVAL         # 1 時間で一度でも発火する確率
    power = fire_prob(n, THR, 0.03)        # 本当に 3% へ劣化したときの検出力
    print(f"{exposure*100:5.0f}%  n={n:5d}  "
          f"発火に必要な失敗={min_k_exceeding(n, THR):3d}件  "
          f"誤発火/回={once*100:5.2f}%  1時間={hour*100:6.2f}%  検出力={power*100:5.2f}%")

// lib/auto-rollback.ts — しきい値に「分母」と「連続回数」を持たせる
interface MetricThreshold {
  metric: string;
  operator: 'gt' | 'lt' | 'gte' | 'lte';
  value: number;
  window: string;
  minSamples: number;           // これを下回るウィンドウは判定しない
  consecutiveViolations: number; // 連続で割った回数だけ発火させる
}
 
const streaks = new Map<string, number>();
 
async function evaluateWithGuard(
  flagKey: string,
  t: MetricThreshold
): Promise<'fire' | 'hold' | 'insufficient'> {
  const { value, samples } = await getMetricWithCount(t.metric, t.window);
  const streakKey = `${flagKey}:${t.metric}`;
 
  // 分母が足りないウィンドウは「異常なし」ではなく「判定不能」として扱う
  if (samples < t.minSamples) {
    streaks.set(streakKey, 0);
    return 'insufficient';
  }
 
  if (!evaluateThreshold(value, t)) {
    streaks.set(streakKey, 0);
    return 'hold';
  }
 
  const streak = (streaks.get(streakKey) ?? 0) + 1;
  streaks.set(streakKey, streak);
  return streak >= t.consecutiveViolations ? 'fire' : 'hold';
}
 
// 曝露率ごとに、担当させる指標そのものを変える
const STAGE_THRESHOLDS: Record<number, MetricThreshold[]> = {
  1: [
    // 1 件で意味が確定する事象だけを見る
    { metric: 'fatal_crash_count', operator: 'gte', value: 1, window: '5m',
      minSamples: 1, consecutiveViolations: 1 },
  ],
  25: [
    { metric: 'error_rate', operator: 'gt', value: 2.0, window: '5m',
      minSamples: 500, consecutiveViolations: 3 },
    { metric: 'p99_latency_ms', operator: 'gt', value: 2000, window: '5m',
      minSamples: 500, consecutiveViolations: 3 },
  ],
};

// scripts/flag-hygiene.ts — 期限切れフラグの検出と除去支援
// Antigravity に「期限切れフラグを検出するスクリプトを作って」と依頼
 
import { readFileSync, readdirSync } from 'fs';
import { join } from 'path';
 
interface FlagAuditResult {
  key: string;
  status: 'active' | 'expired' | 'stale' | 'orphaned';
  expiresAt?: string;
  usageCount: number;   // コード内での参照回数
  lastModified: string; // 最終変更日
  recommendation: string;
}
 
async function auditFlags(projectRoot: string): Promise<FlagAuditResult[]> {
  const results: FlagAuditResult[] = [];
  const now = new Date();
 
  // フラグ定義ファイルを読み込み
  const flagDefs = loadFlagDefinitions(projectRoot);
 
  for (const flag of flagDefs) {
    // コード内での参照回数をカウント
    const usageCount = countFlagUsages(projectRoot, flag.key);
 
    // ステータス判定
    let status: FlagAuditResult['status'] = 'active';
    let recommendation = '';
 
    if (flag.expiresAt && new Date(flag.expiresAt) < now) {
      status = 'expired';
      recommendation = `期限切れ（${flag.expiresAt}）。フラグと関連コードを除去してください。`;
    } else if (usageCount === 0) {
      status = 'orphaned';
      recommendation = 'コード内で未使用。定義を削除してください。';
    } else if (daysSince(flag.createdAt) > 90 && flag.type === 'release') {
      status = 'stale';
      recommendation = '90日以上経過したリリースフラグ。恒久化または除去を検討してください。';
    }
 
    results.push({
      key: flag.key,
      status,
      expiresAt: flag.expiresAt,
      usageCount,
      lastModified: flag.createdAt,
      recommendation,
    });
  }
 
  return results;
}
 
function countFlagUsages(root: string, flagKey: string): number {
  // grep -r で参照回数をカウント
  // 実際には Antigravity エージェントがプロジェクト全体を検索
  let count = 0;
  const srcDir = join(root, 'src');
  // 再帰的にファイルを走査して flagKey の出現回数を数える
  return count;
}
 
function daysSince(dateStr: string): number {
  return Math.floor(
    (Date.now() - new Date(dateStr).getTime()) / (1000 * 60 * 60 * 24)
  );
}
 
function loadFlagDefinitions(root: string): any[] {
  // プロジェクトのフラグ定義を読み込む
  return [];
}
 
// CI で週次実行し、レポートを Slack に投稿:
// npx tsx scripts/flag-hygiene.ts
//
// 出力例:
// 🔍 Flag Audit Report — 2026-03-30
// ────────────────────────────────
// ❌ EXPIRED: new-checkout-flow (expired 2026-03-28)
//    → フラグと関連コードを除去してください
// ⚠️ STALE: legacy-api-fallback (created 120 days ago)
//    → 90日以上経過。恒久化または除去を検討してください
// ✅ ACTIVE: exp-pricing-v2 (expires 2026-04-15, 23 references)
// ✅ ACTIVE: ops-maintenance-mode (no expiry, 5 references)