繰越されない月次クレジットを月初に枯らさず月末に余らせない — バーンレート配分スケジューラの設計

// burn-rate.ts — 残量と残り日数から、今日の許容消費を求める
export interface CreditState {
  monthlyCredit: number;   // その月に確保した枠（USD）。例: 200
  spentThisMonth: number;  // 今月ここまでの実消費（USD）
  spentToday: number;      // 今日ここまでの実消費（USD）
  now: Date;
}
 
export interface PaceDecision {
  remaining: number;       // 残クレジット
  daysLeft: number;        // 今日を含む残り日数
  dailyBudget: number;     // 今日使ってよい上限
  todayHeadroom: number;   // 今日まだ使える余力
  canRun: boolean;         // これ以上、任意実行してよいか
}
 
function daysLeftInMonth(now: Date): number {
  const y = now.getUTCFullYear();
  const m = now.getUTCMonth();
  const lastDay = new Date(Date.UTC(y, m + 1, 0)).getUTCDate();
  return lastDay - now.getUTCDate() + 1; // 今日を含める
}
 
export function decidePace(s: CreditState): PaceDecision {
  const remaining = Math.max(0, s.monthlyCredit - s.spentThisMonth);
  const daysLeft = daysLeftInMonth(s.now);
 
  // 残量ベースの動的な日割り。昨日までの過不足が自動で反映される
  const dailyBudget = remaining / daysLeft;
 
  const todayHeadroom = dailyBudget - s.spentToday;
  return {
    remaining,
    daysLeft,
    dailyBudget,
    todayHeadroom,
    canRun: todayHeadroom > 0,
  };
}

// estimate.ts — タスク種別ごとに、コストを事前見積もりする
type TaskKind = "integrity" | "shortgen" | "longgen" | "review";
 
// 過去実測の中央値（入力/出力トークン）。運用しながら更新する
const MEDIAN_TOKENS: Record<TaskKind, { input: number; output: number }> = {
  integrity: { input: 8_000,   output: 1_500 },
  shortgen:  { input: 40_000,  output: 12_000 },
  longgen:   { input: 180_000, output: 60_000 },
  review:    { input: 90_000,  output: 8_000 },
};
 
// full API レート（USD / 100万トークン）。契約・モデルに合わせて更新する
const RATE = { input: 3.0, output: 15.0 };
 
export function estimateCost(kind: TaskKind): number {
  const t = MEDIAN_TOKENS[kind];
  return (t.input / 1_000_000) * RATE.input
       + (t.output / 1_000_000) * RATE.output;
}

// scheduler.ts — バーンレートと事前見積もりでキューを捌く
import { decidePace, CreditState } from "./burn-rate";
import { estimateCost } from "./estimate";
 
interface Task {
  id: string;
  kind: "integrity" | "shortgen" | "longgen" | "review";
  priority: number;     // 小さいほど高優先
  mustRun?: boolean;    // 安全マージンを使ってでも必ず実行する
}
 
export function planToday(queue: Task[], credit: CreditState) {
  const run: Task[] = [];
  const deferred: Task[] = [];
 
  // 優先度順に並べる
  const sorted = [...queue].sort((a, b) => a.priority - b.priority);
 
  let spentToday = credit.spentToday;
 
  for (const task of sorted) {
    const pace = decidePace({ ...credit, spentToday });
    const cost = estimateCost(task.kind);
 
    // 最優先タスクは安全マージン込みの残量がある限り通す
    if (task.mustRun && pace.remaining - cost > 0) {
      run.push(task);
      spentToday += cost;
      continue;
    }
 
    // 通常タスクは今日の余力の範囲だけ通す
    if (pace.canRun && cost <= pace.todayHeadroom) {
      run.push(task);
      spentToday += cost;
    } else {
      deferred.push(task);
    }
  }
 
  return { run, deferred, spentToday };
}

// 月末スイープ: 残り3日を切ったら残量全体を使い切りにいく
export function endOfMonthSweep(deferred: Task[], pace: { remaining: number; daysLeft: number }) {
  if (pace.daysLeft > 3) return [];
  const picked: Task[] = [];
  let budget = pace.remaining;
  for (const t of deferred.sort((a, b) => a.priority - b.priority)) {
    const cost = estimateCost(t.kind);
    if (cost <= budget) {
      picked.push(t);
      budget -= cost;
    }
  }
  return picked;
}