@m8i-51/shoal 0.1.6 → 0.1.8

package/framework/__tests__/cost.test.ts

@@ -0,0 +1,118 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { estimateCost, formatCostUSD } from "../cost";
+
+// OpenRouter のフェッチをモック（ネットワーク不要）
+vi.stubGlobal("fetch", vi.fn());
+
+beforeEach(() => {
+  vi.mocked(fetch).mockResolvedValue({
+    ok: false,
+    status: 503,
+    json: async () => ({}),
+    text: async () => "",
+  } as Response);
+});
+
+describe("formatCostUSD", () => {
+  it("null / undefined は —", () => {
+    expect(formatCostUSD(null)).toBe("—");
+    expect(formatCostUSD(undefined)).toBe("—");
+  });
+
+  it("0.00005 未満は < $0.0001", () => {
+    expect(formatCostUSD(0.000005)).toBe("< $0.0001");
+  });
+
+  it("0.0001 以上 0.01 未満は 4 桁小数", () => {
+    expect(formatCostUSD(0.0023)).toBe("$0.0023");
+  });
+
+  it("0.01 以上 1 未満は 3 桁小数", () => {
+    expect(formatCostUSD(0.123)).toBe("$0.123");
+  });
+
+  it("1 以上は 2 桁小数", () => {
+    expect(formatCostUSD(2.5)).toBe("$2.50");
+  });
+});
+
+describe("estimateCost — free providers", () => {
+  it.each(["ollama", "lm-studio", "codex", "local"])("%s は null を返す", async (provider) => {
+    expect(await estimateCost("any-model", provider, 1000, 500)).toBeNull();
+  });
+});
+
+describe("estimateCost — Anthropic", () => {
+  it("claude-haiku-4-5-20251001 の料金を計算する", async () => {
+    const cost = await estimateCost("claude-haiku-4-5-20251001", "anthropic", 1_000_000, 500_000);
+    // input: 0.8/1M × 1M = 0.8, output: 4/1M × 500k = 2.0 → 2.8
+    expect(cost).toBeCloseTo(2.8, 5);
+  });
+
+  it("prefix match — claude-haiku-4-5-xxx はキーに一致する", async () => {
+    const cost = await estimateCost("claude-haiku-4-5-some-suffix", "anthropic", 1_000_000, 0);
+    expect(cost).toBeCloseTo(0.8, 5);
+  });
+
+  it("不明モデルは null", async () => {
+    expect(await estimateCost("claude-unknown-9999", "anthropic", 1000, 500)).toBeNull();
+  });
+
+  it("claude-sonnet-4-6 の料金を計算する", async () => {
+    const cost = await estimateCost("claude-sonnet-4-6", "anthropic", 1_000_000, 1_000_000);
+    // input: 3/1M + output: 15/1M = 18
+    expect(cost).toBeCloseTo(18, 5);
+  });
+});
+
+describe("estimateCost — Bedrock", () => {
+  it("anthropic.claude-3-5-haiku-20241022-v1:0 の料金を計算する", async () => {
+    const cost = await estimateCost("anthropic.claude-3-5-haiku-20241022-v1:0", "bedrock", 1_000_000, 1_000_000);
+    // input: 0.8/1M + output: 4/1M = 4.8
+    expect(cost).toBeCloseTo(4.8, 5);
+  });
+
+  it("クロスリージョンプレフィックス us. を除去してマッチする", async () => {
+    const direct = await estimateCost("anthropic.claude-3-5-sonnet-20241022-v2:0", "bedrock", 1_000_000, 0);
+    const crossRegion = await estimateCost("us.anthropic.claude-3-5-sonnet-20241022-v2:0", "bedrock", 1_000_000, 0);
+    expect(crossRegion).toBeCloseTo(direct!, 8);
+  });
+
+  it("不明モデルは null", async () => {
+    expect(await estimateCost("anthropic.claude-unknown-v99:0", "bedrock", 1000, 500)).toBeNull();
+  });
+});
+
+describe("estimateCost — OpenAI", () => {
+  it("gpt-4o の料金を計算する", async () => {
+    const cost = await estimateCost("gpt-4o", "openai", 1_000_000, 1_000_000);
+    // input: 5/1M + output: 15/1M = 20
+    expect(cost).toBeCloseTo(20, 5);
+  });
+
+  it("gpt-4o-mini の料金を計算する", async () => {
+    const cost = await estimateCost("gpt-4o-mini", "openai", 1_000_000, 1_000_000);
+    expect(cost).toBeCloseTo(0.75, 5);
+  });
+
+  it("不明モデルは null", async () => {
+    expect(await estimateCost("gpt-unknown", "openai", 1000, 500)).toBeNull();
+  });
+});
+
+describe("estimateCost — OpenRouter", () => {
+  it("fetch 失敗時は null を返す", async () => {
+    expect(await estimateCost("some/model", "openrouter", 1000, 500)).toBeNull();
+  });
+
+  it("fetch 成功時はレスポンスの料金を使う", async () => {
+    vi.mocked(fetch).mockResolvedValueOnce({
+      ok: true,
+      json: async () => ({
+        data: [{ id: "some/model", pricing: { prompt: "0.000003", completion: "0.000015" } }],
+      }),
+    } as Response);
+    const cost = await estimateCost("some/model", "openrouter", 1_000_000, 1_000_000);
+    expect(cost).toBeCloseTo(18, 5);
+  });
+});

package/framework/__tests__/coverage.test.ts

@@ -167,6 +167,86 @@ describe("computeWeightedSummary", () => {
     expect(result.formatted).toContain("By scenario");
   });
 
+  it("14日以内に同じレンズが複数 run に登場するとボーナスが乗る", () => {
+    const now = Date.now();
+    // 同じ Accessibility レンズが2回登場 → bonus = 1 + (2-1)*0.5 = 1.5
+    setupMockCoverage({
+      entries: [
+        makeEntry({
+          runId: "run_1",
+          timestamp: new Date(now - 1000).toISOString(),
+          findingsCount: 2,
+          byLens: { Accessibility: 2 },
+        }),
+        makeEntry({
+          runId: "run_2",
+          timestamp: new Date(now).toISOString(),
+          findingsCount: 2,
+          byLens: { Accessibility: 2 },
+        }),
+      ],
+    });
+
+    const resultWithRepeat = computeWeightedSummary();
+
+    // 1回しか登場しない場合と比較
+    setupMockCoverage({
+      entries: [
+        makeEntry({
+          runId: "run_1",
+          timestamp: new Date(now).toISOString(),
+          findingsCount: 2,
+          byLens: { Accessibility: 2 },
+        }),
+      ],
+    });
+    const resultSingle = computeWeightedSummary();
+
+    // 繰り返しありのほうが lens の重みが高いはず
+    expect(resultWithRepeat.byLens["Accessibility"]).toBeGreaterThan(resultSingle.byLens["Accessibility"]);
+  });
+
+  it("14日より古いエントリーは繰り返しカウントに含まれない", () => {
+    const now = Date.now();
+    const oldMs = 15 * 24 * 60 * 60 * 1000; // 15日前
+    setupMockCoverage({
+      entries: [
+        makeEntry({
+          runId: "run_old",
+          timestamp: new Date(now - oldMs).toISOString(),
+          findingsCount: 2,
+          byLens: { Security: 2 },
+        }),
+        makeEntry({
+          runId: "run_new",
+          timestamp: new Date(now).toISOString(),
+          findingsCount: 2,
+          byLens: { Security: 2 },
+        }),
+      ],
+    });
+
+    const result = computeWeightedSummary();
+    // 古いエントリーはウィンドウ外なのでボーナスなし（繰り返し回数=1 → bonus=1.0）
+    // ボーナスなしの場合: weight≈1.0*2 + 15日前のdecay*2 ≈ 2.06
+    expect(result.formatted).not.toContain("Repeated lenses");
+  });
+
+  it("繰り返しレンズが formatted に含まれる", () => {
+    const now = Date.now();
+    setupMockCoverage({
+      entries: [
+        makeEntry({ runId: "r1", timestamp: new Date(now - 1000).toISOString(), findingsCount: 1, byLens: { "UI design": 1 } }),
+        makeEntry({ runId: "r2", timestamp: new Date(now).toISOString(), findingsCount: 1, byLens: { "UI design": 1 } }),
+      ],
+    });
+
+    const result = computeWeightedSummary();
+    expect(result.formatted).toContain("Repeated lenses");
+    expect(result.formatted).toContain("UI design");
+    expect(result.formatted).toContain("×2");
+  });
+
   it("MAX_ENTRIES を超えると最新30件に切り捨てる", () => {
     const entries = Array.from({ length: 35 }, (_, i) =>
       makeEntry({

package/framework/__tests__/report.test.ts

@@ -1,6 +1,8 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
 import * as fs from "fs";
 import * as path from "path";
+import type { AgentLog, RegressionCheck } from "../types";
+import type { ScenarioOutcome } from "../scenario-designer";
 
 vi.mock("fs");
 vi.mock("path", async (importOriginal) => {
@@ -41,6 +43,22 @@ function makeRunLog(overrides: Partial<RunLog> = {}): RunLog {
   };
 }
 
+function makeAgentLog(overrides: Partial<AgentLog> = {}): AgentLog {
+  return {
+    agentId: "a1",
+    agentName: "Alice",
+    agentType: "browser",
+    role: "tester",
+    status: "completed",
+    iterations: 3,
+    issuesPosted: [],
+    regressionChecks: [],
+    startedAt: "2026-04-27T00:01:00.000Z",
+    completedAt: "2026-04-27T00:03:00.000Z",
+    ...overrides,
+  };
+}
+
 function makeProductSpec(overrides: Partial<ProductSpec> = {}): ProductSpec {
   return {
     appName: "Test App",
@@ -138,6 +156,76 @@ describe("generateReport", () => {
     expect(html).toContain("lens");
   });
 
+  it("エージェントテーブルにエージェント名と status が含まれる", () => {
+    const agent = makeAgentLog({ agentName: "Bob", status: "completed" });
+    generateReport(makeRunLog({ agents: [agent] }), [], emptyTriage, makeProductSpec(), [], new Map());
+    const html = getSavedHtml();
+    expect(html).toContain("Bob");
+    expect(html).toContain("completed");
+  });
+
+  it("regression エージェントに regression バッジが付く", () => {
+    const agent = makeAgentLog({ agentType: "regression" });
+    generateReport(makeRunLog({ agents: [agent] }), [], emptyTriage, makeProductSpec(), [], new Map());
+    expect(getSavedHtml()).toContain("regression");
+  });
+
+  it("regression checks がある場合 Progress セクションが表示される", () => {
+    const checks: RegressionCheck[] = [
+      { issueNumber: 42, issueTitle: "Login button broken", status: "fixed" },
+    ];
+    const agent = makeAgentLog({ agentType: "regression", regressionChecks: checks });
+    generateReport(makeRunLog({ agents: [agent] }), [], emptyTriage, makeProductSpec(), [], new Map());
+    const html = getSavedHtml();
+    expect(html).toContain("Progress");
+    expect(html).toContain("#42");
+    expect(html).toContain("Login button broken");
+    expect(html).toContain("✓ fixed");
+  });
+
+  it("regression が再発した場合 regressed バッジが表示される", () => {
+    const checks: RegressionCheck[] = [
+      { issueNumber: 7, issueTitle: "Crash on submit", status: "regressed" },
+    ];
+    const agent = makeAgentLog({ agentType: "regression", regressionChecks: checks });
+    generateReport(makeRunLog({ agents: [agent] }), [], emptyTriage, makeProductSpec(), [], new Map());
+    expect(getSavedHtml()).toContain("⚠ regressed");
+  });
+
+  it("regression checks がない場合 Progress セクションは表示されない", () => {
+    generateReport(makeRunLog(), [], emptyTriage, makeProductSpec(), [], new Map());
+    expect(getSavedHtml()).not.toContain("Progress (");
+  });
+
+  it("ScenarioOutcomes が achieved の場合 achieved バッジが表示される", () => {
+    const outcomes: ScenarioOutcome[] = [{
+      scenarioId: "s1",
+      scenarioTitle: "New employee task",
+      agentId: "a1",
+      agentName: "Alice",
+      achieved: true,
+      reason: "Completed successfully",
+    }];
+    generateReport(makeRunLog(), [], emptyTriage, makeProductSpec(), [], new Map(), outcomes);
+    const html = getSavedHtml();
+    expect(html).toContain("Scenario Outcomes");
+    expect(html).toContain("achieved");
+    expect(html).toContain("New employee task");
+  });
+
+  it("ScenarioOutcomes が failed の場合 failed バッジが表示される", () => {
+    const outcomes: ScenarioOutcome[] = [{
+      scenarioId: "s1",
+      scenarioTitle: "Purchase flow",
+      agentId: "a1",
+      agentName: "Bob",
+      achieved: false,
+      reason: "Could not find the button",
+    }];
+    generateReport(makeRunLog(), [], emptyTriage, makeProductSpec(), [], new Map(), outcomes);
+    expect(getSavedHtml()).toContain("failed");
+  });
+
   it("finding が issued → unprocessed → skipped の順に並ぶ", () => {
     const f1 = makeFinding({ id: "f1", title: "Issued Finding" });
     const f2 = makeFinding({ id: "f2", title: "Skipped Finding" });

package/framework/coverage.ts

@@ -27,6 +27,9 @@ export interface WeightedSummary {
 const COVERAGE_PATH = path.join(process.cwd(), "coverage", "coverage.json");
 const MAX_ENTRIES = 30;
 const HALF_LIFE_DAYS = 7;
+const REPETITION_WINDOW_DAYS = 14;
+const REPETITION_BONUS = 0.005;
+const REPETITION_EXPONENT = 3;
 
 export function loadCoverage(): Coverage {
   try {
@@ -98,6 +101,20 @@ export function computeWeightedSummary(): WeightedSummary {
 
   const now = Date.now();
   const halfLifeMs = HALF_LIFE_DAYS * 24 * 60 * 60 * 1000;
+  const windowMs = REPETITION_WINDOW_DAYS * 24 * 60 * 60 * 1000;
+
+  // 14日以内の run で各 lens/scenario が何回登場したかを数える
+  const lensRepeat: Record<string, number> = {};
+  const scenarioRepeat: Record<string, number> = {};
+  for (const entry of coverage.entries) {
+    if (now - new Date(entry.timestamp).getTime() > windowMs) continue;
+    for (const lens of Object.keys(entry.byLens)) {
+      lensRepeat[lens] = (lensRepeat[lens] ?? 0) + 1;
+    }
+    for (const title of Object.keys(entry.byScenario ?? {})) {
+      scenarioRepeat[title] = (scenarioRepeat[title] ?? 0) + 1;
+    }
+  }
 
   const byCategory: Record<string, number> = {};
   const byLens: Record<string, number> = {};
@@ -106,18 +123,21 @@ export function computeWeightedSummary(): WeightedSummary {
 
   for (const entry of coverage.entries) {
     const age = now - new Date(entry.timestamp).getTime();
-    const weight = Math.pow(0.5, age / halfLifeMs);
+    const decay = Math.pow(0.5, age / halfLifeMs);
 
     for (const [cat, count] of Object.entries(entry.byCategory)) {
-      byCategory[cat] = (byCategory[cat] ?? 0) + count * weight;
+      byCategory[cat] = (byCategory[cat] ?? 0) + count * decay;
     }
     for (const [lens, count] of Object.entries(entry.byLens)) {
-      byLens[lens] = (byLens[lens] ?? 0) + count * weight;
+      // 繰り返し呼ばれるほど「必要」とみなしてボーナスを加算
+      const bonus = 1 + Math.pow((lensRepeat[lens] ?? 1) - 1, REPETITION_EXPONENT) * REPETITION_BONUS;
+      byLens[lens] = (byLens[lens] ?? 0) + count * decay * bonus;
     }
     for (const [title, count] of Object.entries(entry.byScenario ?? {})) {
-      byScenario[title] = (byScenario[title] ?? 0) + count * weight;
+      const bonus = 1 + Math.pow((scenarioRepeat[title] ?? 1) - 1, REPETITION_EXPONENT) * REPETITION_BONUS;
+      byScenario[title] = (byScenario[title] ?? 0) + count * decay * bonus;
     }
-    totalWeighted += entry.findingsCount * weight;
+    totalWeighted += entry.findingsCount * decay;
   }
 
   // 小数点1桁に丸める
@@ -142,12 +162,27 @@ export function computeWeightedSummary(): WeightedSummary {
     ? `By scenario: ${sortedScenario.map(([t, c]) => `"${t}" (${c})`).join(", ")}`
     : null;
 
+  const repeatedLenses = Object.entries(lensRepeat)
+    .filter(([, n]) => n > 1)
+    .sort((a, b) => b[1] - a[1])
+    .map(([l, n]) => `${l} (×${n})`);
+  const repeatedScenarios = Object.entries(scenarioRepeat)
+    .filter(([, n]) => n > 1)
+    .sort((a, b) => b[1] - a[1])
+    .map(([t, n]) => `"${t}" (×${n})`);
+
   const formatted = [
-    `Coverage summary (half-life: ${HALF_LIFE_DAYS} days, ${coverage.entries.length} run(s) tracked):`,
+    `Coverage summary (half-life: ${HALF_LIFE_DAYS} days, repetition window: ${REPETITION_WINDOW_DAYS} days, ${coverage.entries.length} run(s) tracked):`,
     `Total weighted findings: ${totalWeighted}`,
     `By lens: ${sortedLens.map(([l, c]) => `${l} (${c})`).join(" > ") || "(none)"}`,
     scenarioLine,
     `By category: ${sortedCategory.map(([c, n]) => `${c} (${n})`).join(" > ") || "(none)"}`,
+    repeatedLenses.length > 0
+      ? `Repeated lenses (bonus applied): ${repeatedLenses.join(", ")}`
+      : null,
+    repeatedScenarios.length > 0
+      ? `Repeated scenarios (bonus applied): ${repeatedScenarios.join(", ")}`
+      : null,
     underrepresented.length > 0
       ? `Underrepresented lenses: ${underrepresented.join(", ")} — consider recruiting agents with these perspectives`
       : "All lenses have comparable coverage",

package/framework/org-designer.ts

@@ -14,7 +14,7 @@ export const UNIVERSAL_LENSES = [
   "Business logic: calculation accuracy, status transitions, approval flow correctness, edge case handling in forms / ビジネスロジック観点",
   "Data integrity: UI reflects actual state after actions, silent save failures, optimistic update inconsistencies / データ整合性観点",
   "New user: first-time usability, onboarding clarity, instruction completeness, error recovery, empty state messaging / 新規ユーザー観点",
-  "UX design: interaction feedback (loading states, success/error messages), form usability, modal and dialog behavior, navigation consistency, micro-interactions — evaluate against established patterns from Apple HIG and Material Design (clear affordances, immediate feedback, forgiving interactions) / UXデザイン観点",
+  "UX design: interaction feedback (loading states, success/error messages), form usability, modal and dialog behavior, navigation consistency, micro-interactions — evaluate against established HCI principles: Fitts's Law (are touch/click targets large and close enough?), Hick's Law (are choices overwhelming?), Miller's Law (is the amount of information shown at once within cognitive limits?), Jakob's Law (does the app behave like similar apps users already know?), Nielsen's heuristics (visibility of system status, error prevention, recognition over recall) / UXデザイン観点",
   "Visual design: spacing and alignment consistency, typography hierarchy, color usage and contrast, component coherence across screens, mobile responsiveness — flag anything that looks broken, cramped, or visually inconsistent / ビジュアルデザイン観点",
   "Product/PM: feature discoverability, user journey clarity, obvious next actions, drop-off risk points, call-to-action prominence, whether the app communicates its value clearly, missing features that users of this type would expect / プロダクト・PM観点",
   "Power user: keyboard shortcuts availability, bulk operations, filtering/sorting depth, export options, API access, customization options / パワーユーザー観点",
@@ -78,7 +78,13 @@ ${UNIVERSAL_LENSES.map((l) => `- ${l}`).join("\n")}
 When recruiting UX/design-oriented agents, give them awareness of these standards:
 - Apple HIG: clear visual hierarchy, immediate feedback, forgiveness (undo/cancel), consistent navigation, minimal cognitive load
 - Material Design: meaningful motion, bold clear typography, responsive layout, accessible color contrast (WCAG AA minimum)
-- General web conventions: F-pattern reading, above-the-fold CTAs, error prevention over error recovery, progressive disclosure for complex forms`;
+- General web conventions: F-pattern reading, above-the-fold CTAs, error prevention over error recovery, progressive disclosure for complex forms
+- HCI principles to apply when exploring:
+  - Fitts's Law: notice when important buttons are small, far from natural cursor/thumb position, or hard to tap on mobile
+  - Hick's Law: flag screens with too many choices that slow down decision-making
+  - Miller's Law: flag when more than ~7 items are shown without grouping or progressive disclosure
+  - Jakob's Law: flag interactions that contradict conventions users expect from similar apps (e.g., swipe to delete, pull to refresh, hamburger menus)
+  - Nielsen's heuristics: check for missing system status feedback, unclear error messages, lack of undo, and forcing users to recall rather than recognize`;
 
   console.log("[org-design] done");
   return { hrGuidance };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@m8i-51/shoal",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "type": "module",
   "description": "Multi-agent web exploration framework — finds bugs, UX issues, and missing features by running AI agents against your app",
   "repository": {
@@ -50,6 +50,7 @@
     "@types/react": "^19.2.14",
     "@types/react-dom": "^19.2.3",
     "@vitejs/plugin-react": "^4.7.0",
+    "@vitest/coverage-v8": "^4.1.6",
     "concurrently": "^9.2.1",
     "i18next": "^26.0.6",
     "react": "^19.2.5",

package/server/__tests__/scheduler.test.ts

@@ -0,0 +1,134 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import * as fs from "fs";
+
+vi.mock("fs");
+vi.mock("path", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("path")>();
+  return { ...actual, join: (...args: string[]) => args.join("/") };
+});
+vi.mock("../runner.js", () => ({ spawnRun: vi.fn() }));
+
+import { loadSchedule, saveSchedule, type ScheduleConfig } from "../scheduler";
+import { spawnRun } from "../runner.js";
+
+const DEFAULT: ScheduleConfig = {
+  enabled: false,
+  dayOfWeek: 1,
+  hour: 9,
+  minute: 0,
+  lastRunDate: null,
+};
+
+beforeEach(() => {
+  vi.mocked(fs.existsSync).mockReturnValue(false);
+  vi.mocked(fs.readFileSync).mockReturnValue("{}");
+  vi.mocked(fs.writeFileSync).mockReturnValue(undefined);
+});
+
+afterEach(() => {
+  vi.clearAllMocks();
+});
+
+describe("loadSchedule", () => {
+  it("ファイルがない場合はデフォルト設定を返す", () => {
+    vi.mocked(fs.existsSync).mockReturnValue(false);
+    expect(loadSchedule()).toEqual(DEFAULT);
+  });
+
+  it("ファイルがある場合は設定を読み込む", () => {
+    const saved: ScheduleConfig = { enabled: true, dayOfWeek: 3, hour: 14, minute: 30, lastRunDate: "2026-05-12" };
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(saved));
+    expect(loadSchedule()).toEqual(saved);
+  });
+
+  it("ファイルが壊れている場合はデフォルトを返す", () => {
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    vi.mocked(fs.readFileSync).mockReturnValue("invalid json{{{");
+    expect(loadSchedule()).toEqual(DEFAULT);
+  });
+
+  it("部分的な設定はデフォルトとマージされる", () => {
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({ enabled: true }));
+    expect(loadSchedule()).toEqual({ ...DEFAULT, enabled: true });
+  });
+});
+
+describe("saveSchedule", () => {
+  it("設定を JSON ファイルに書き出す", () => {
+    const config: ScheduleConfig = { enabled: true, dayOfWeek: 1, hour: 9, minute: 0, lastRunDate: null };
+    saveSchedule(config);
+    const [, content] = vi.mocked(fs.writeFileSync).mock.calls[0];
+    expect(JSON.parse(content as string)).toEqual(config);
+  });
+});
+
+describe("scheduler — 時刻判定ロジック", () => {
+  it("enabled=false のときは spawnRun を呼ばない", async () => {
+    vi.useFakeTimers();
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify({ ...DEFAULT, enabled: false }));
+
+    vi.resetModules();
+    const { startScheduler } = await import("../scheduler");
+    startScheduler();
+
+    // 最初の setTimeout（次の分の頭）+ check が走る分だけ進める
+    await vi.advanceTimersByTimeAsync(61_000);
+    expect(spawnRun).not.toHaveBeenCalled();
+    vi.useRealTimers();
+  });
+
+  it("スケジュール時刻に一致したとき spawnRun を呼ぶ", async () => {
+    vi.useFakeTimers();
+
+    // 月曜 09:00 に固定（UTC = ローカルとして扱う）
+    const monday9am = new Date("2026-05-11T09:00:00.000Z");
+    vi.setSystemTime(monday9am);
+
+    const config: ScheduleConfig = {
+      enabled: true,
+      dayOfWeek: monday9am.getDay(),
+      hour: monday9am.getHours(),
+      minute: monday9am.getMinutes(),
+      lastRunDate: null,
+    };
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(config));
+
+    vi.resetModules();
+    const { startScheduler: start } = await import("../scheduler");
+    start();
+
+    await vi.advanceTimersByTimeAsync(61_000);
+    expect(spawnRun).toHaveBeenCalledOnce();
+    vi.useRealTimers();
+  });
+
+  it("同日に既に実行済みなら spawnRun を呼ばない", async () => {
+    vi.useFakeTimers();
+
+    const monday9am = new Date("2026-05-11T09:00:00.000Z");
+    vi.setSystemTime(monday9am);
+    const today = monday9am.toISOString().slice(0, 10);
+
+    const config: ScheduleConfig = {
+      enabled: true,
+      dayOfWeek: monday9am.getDay(),
+      hour: monday9am.getHours(),
+      minute: monday9am.getMinutes(),
+      lastRunDate: today,
+    };
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+    vi.mocked(fs.readFileSync).mockReturnValue(JSON.stringify(config));
+
+    vi.resetModules();
+    const { startScheduler: start } = await import("../scheduler");
+    start();
+
+    await vi.advanceTimersByTimeAsync(61_000);
+    expect(spawnRun).not.toHaveBeenCalled();
+    vi.useRealTimers();
+  });
+});